{ "cells": [ { "cell_type": "markdown", "id": "f1822fc3-a9ee-4cea-8096-6ced40479730", "metadata": {}, "source": [ "# Classification" ] }, { "cell_type": "markdown", "id": "58097093-edaa-43e0-9cba-8e5ffac261ca", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "id": "3d4cbf3c-1fc4-45d3-9dbc-54a4ef021c03", "metadata": {}, "source": [ "### Dataset Download \n", "You can download the CSV file here: \n", "[https://www.kaggle.com/competitions/playground-series-s5e3/data)" ] }, { "cell_type": "markdown", "id": "074deefc-4f22-42c1-a9da-f2cd10ebb926", "metadata": {}, "source": [ "### Introduction\n", "The goal of this project is to predict whether it will rain using daily weather data.\n", "This is a binary classification problem, and the model predicts the probability of rainfall." ] }, { "cell_type": "markdown", "id": "04707f5f-fbaf-40d0-84bf-eaae40761beb", "metadata": {}, "source": [ "### Import Libraries" ] }, { "cell_type": "code", "execution_count": 101, "id": "9f2245ee-bd9e-4dc8-b0fb-6b6aa2f2e67b", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import numpy as np\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n", "from sklearn.linear_model import LogisticRegression\n", "from lightgbm import LGBMClassifier\n", "from catboost import CatBoostClassifier\n", "from xgboost import XGBClassifier\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.naive_bayes import BernoulliNB\n", "from sklearn.metrics import roc_auc_score\n", "from sklearn.metrics import roc_curve,auc\n", "import joblib\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "pd.set_option('display.max_columns',100)" ] }, { "cell_type": "markdown", "id": "cbb71464-c774-4b61-97e0-1fca53e0da3f", "metadata": {}, "source": [ "### Load Data" ] }, { "cell_type": "code", "execution_count": 2, "id": "351cb1cd-65ff-473a-bce2-ca6e94ed19b1", "metadata": {}, "outputs": [], "source": [ "df1=pd.read_csv('train.csv')" ] }, { "cell_type": "code", "execution_count": 3, "id": "adca0a24-7cd9-48d6-a57e-f1121d79fff2", "metadata": {}, "outputs": [], "source": [ "df2=pd.read_csv('test.csv')" ] }, { "cell_type": "code", "execution_count": 4, "id": "9c0b706e-543b-439a-b2f0-49bfad02b621", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
iddaypressuremaxtemptemparaturemintempdewpointhumiditycloudsunshinewinddirectionwindspeedrainfall
0011017.421.220.619.919.487.088.01.160.017.21
1121019.516.216.915.815.495.091.00.050.021.91
2231024.119.416.114.69.375.047.08.370.018.11
3341013.418.117.816.916.895.095.00.060.035.61
4451021.821.318.415.29.652.045.03.640.024.80
\n", "
" ], "text/plain": [ " id day pressure maxtemp temparature mintemp dewpoint humidity \\\n", "0 0 1 1017.4 21.2 20.6 19.9 19.4 87.0 \n", "1 1 2 1019.5 16.2 16.9 15.8 15.4 95.0 \n", "2 2 3 1024.1 19.4 16.1 14.6 9.3 75.0 \n", "3 3 4 1013.4 18.1 17.8 16.9 16.8 95.0 \n", "4 4 5 1021.8 21.3 18.4 15.2 9.6 52.0 \n", "\n", " cloud sunshine winddirection windspeed rainfall \n", "0 88.0 1.1 60.0 17.2 1 \n", "1 91.0 0.0 50.0 21.9 1 \n", "2 47.0 8.3 70.0 18.1 1 \n", "3 95.0 0.0 60.0 35.6 1 \n", "4 45.0 3.6 40.0 24.8 0 " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1.head()" ] }, { "cell_type": "code", "execution_count": 5, "id": "7552d292-ffdb-48aa-af90-96ce3384268f", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
iddaypressuremaxtemptemparaturemintempdewpointhumiditycloudsunshinewinddirectionwindspeedrainfall
218521853611014.623.220.619.119.997.088.00.140.022.11
218621863621012.417.217.316.315.391.088.00.050.035.31
218721873631013.319.016.314.312.679.079.05.040.032.91
218821883641022.316.415.213.814.792.093.00.140.018.01
218921893651013.821.219.118.018.089.088.01.070.048.01
\n", "
" ], "text/plain": [ " id day pressure maxtemp temparature mintemp dewpoint humidity \\\n", "2185 2185 361 1014.6 23.2 20.6 19.1 19.9 97.0 \n", "2186 2186 362 1012.4 17.2 17.3 16.3 15.3 91.0 \n", "2187 2187 363 1013.3 19.0 16.3 14.3 12.6 79.0 \n", "2188 2188 364 1022.3 16.4 15.2 13.8 14.7 92.0 \n", "2189 2189 365 1013.8 21.2 19.1 18.0 18.0 89.0 \n", "\n", " cloud sunshine winddirection windspeed rainfall \n", "2185 88.0 0.1 40.0 22.1 1 \n", "2186 88.0 0.0 50.0 35.3 1 \n", "2187 79.0 5.0 40.0 32.9 1 \n", "2188 93.0 0.1 40.0 18.0 1 \n", "2189 88.0 1.0 70.0 48.0 1 " ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1.tail()" ] }, { "cell_type": "code", "execution_count": 6, "id": "d2d023ba-8019-4a91-83b1-d140d6e32d67", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
iddaypressuremaxtemptemparaturemintempdewpointhumiditycloudsunshinewinddirectionwindspeed
0219011019.517.515.812.714.996.099.00.050.024.3
1219121016.517.516.515.815.197.099.00.050.035.3
2219231023.911.210.49.48.986.096.00.040.016.9
3219341022.920.617.315.29.575.045.07.120.050.6
4219451022.216.113.86.44.368.049.09.220.019.4
\n", "
" ], "text/plain": [ " id day pressure maxtemp temparature mintemp dewpoint humidity \\\n", "0 2190 1 1019.5 17.5 15.8 12.7 14.9 96.0 \n", "1 2191 2 1016.5 17.5 16.5 15.8 15.1 97.0 \n", "2 2192 3 1023.9 11.2 10.4 9.4 8.9 86.0 \n", "3 2193 4 1022.9 20.6 17.3 15.2 9.5 75.0 \n", "4 2194 5 1022.2 16.1 13.8 6.4 4.3 68.0 \n", "\n", " cloud sunshine winddirection windspeed \n", "0 99.0 0.0 50.0 24.3 \n", "1 99.0 0.0 50.0 35.3 \n", "2 96.0 0.0 40.0 16.9 \n", "3 45.0 7.1 20.0 50.6 \n", "4 49.0 9.2 20.0 19.4 " ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2.head()" ] }, { "cell_type": "code", "execution_count": 7, "id": "73169afb-21e3-4767-9925-0cb4f9598c66", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
iddaypressuremaxtemptemparaturemintempdewpointhumiditycloudsunshinewinddirectionwindspeed
72529153611020.818.217.616.113.796.095.00.020.034.3
72629163621011.723.218.116.016.078.080.01.640.025.2
72729173631022.721.018.517.015.592.096.00.050.021.9
72829183641014.421.020.019.719.894.093.00.050.039.5
72929193651020.922.218.817.013.379.089.00.260.050.6
\n", "
" ], "text/plain": [ " id day pressure maxtemp temparature mintemp dewpoint humidity \\\n", "725 2915 361 1020.8 18.2 17.6 16.1 13.7 96.0 \n", "726 2916 362 1011.7 23.2 18.1 16.0 16.0 78.0 \n", "727 2917 363 1022.7 21.0 18.5 17.0 15.5 92.0 \n", "728 2918 364 1014.4 21.0 20.0 19.7 19.8 94.0 \n", "729 2919 365 1020.9 22.2 18.8 17.0 13.3 79.0 \n", "\n", " cloud sunshine winddirection windspeed \n", "725 95.0 0.0 20.0 34.3 \n", "726 80.0 1.6 40.0 25.2 \n", "727 96.0 0.0 50.0 21.9 \n", "728 93.0 0.0 50.0 39.5 \n", "729 89.0 0.2 60.0 50.6 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2.tail()" ] }, { "cell_type": "code", "execution_count": 8, "id": "c958d2fd-b39a-4a81-91db-d01d84435794", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2190, 13)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1.shape" ] }, { "cell_type": "code", "execution_count": 9, "id": "0f33a15d-b47c-448b-9db5-689cf03a7b88", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(730, 12)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2.shape" ] }, { "cell_type": "code", "execution_count": 10, "id": "2dd14ac2-2357-4011-b55e-565a85fb5f44", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 2190 entries, 0 to 2189\n", "Data columns (total 13 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 id 2190 non-null int64 \n", " 1 day 2190 non-null int64 \n", " 2 pressure 2190 non-null float64\n", " 3 maxtemp 2190 non-null float64\n", " 4 temparature 2190 non-null float64\n", " 5 mintemp 2190 non-null float64\n", " 6 dewpoint 2190 non-null float64\n", " 7 humidity 2190 non-null float64\n", " 8 cloud 2190 non-null float64\n", " 9 sunshine 2190 non-null float64\n", " 10 winddirection 2190 non-null float64\n", " 11 windspeed 2190 non-null float64\n", " 12 rainfall 2190 non-null int64 \n", "dtypes: float64(10), int64(3)\n", "memory usage: 222.6 KB\n" ] } ], "source": [ "df1.info()" ] }, { "cell_type": "code", "execution_count": 11, "id": "23fbf628-be15-45ab-9df4-ff5b94d34107", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 730 entries, 0 to 729\n", "Data columns (total 12 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 id 730 non-null int64 \n", " 1 day 730 non-null int64 \n", " 2 pressure 730 non-null float64\n", " 3 maxtemp 730 non-null float64\n", " 4 temparature 730 non-null float64\n", " 5 mintemp 730 non-null float64\n", " 6 dewpoint 730 non-null float64\n", " 7 humidity 730 non-null float64\n", " 8 cloud 730 non-null float64\n", " 9 sunshine 730 non-null float64\n", " 10 winddirection 729 non-null float64\n", " 11 windspeed 730 non-null float64\n", "dtypes: float64(10), int64(2)\n", "memory usage: 68.6 KB\n" ] } ], "source": [ "df2.info()" ] }, { "cell_type": "code", "execution_count": 12, "id": "fa1e3ec5-b8d8-4056-ae6b-ff8db9a393e4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "id 0\n", "day 0\n", "pressure 0\n", "maxtemp 0\n", "temparature 0\n", "mintemp 0\n", "dewpoint 0\n", "humidity 0\n", "cloud 0\n", "sunshine 0\n", "winddirection 0\n", "windspeed 0\n", "rainfall 0\n", "dtype: int64" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1.isnull().sum()" ] }, { "cell_type": "code", "execution_count": 13, "id": "46c8a0be-c098-418a-907e-704ad0fffa0a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "id 0\n", "day 0\n", "pressure 0\n", "maxtemp 0\n", "temparature 0\n", "mintemp 0\n", "dewpoint 0\n", "humidity 0\n", "cloud 0\n", "sunshine 0\n", "winddirection 1\n", "windspeed 0\n", "dtype: int64" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2.isnull().sum()" ] }, { "cell_type": "code", "execution_count": 29, "id": "54557dd2-7a9c-42e7-b356-327300cf2224", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(12,8))\n", "sns.heatmap(df1.corr(numeric_only=True)[['rainfall']].sort_values('rainfall', ascending=False),annot=True, cmap='coolwarm')\n", "plt.title('Correlation with rainfall')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 15, "id": "9c4ef0a1-7703-4910-aae9-9dee6edae488", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sns.kdeplot(data=df1,x='humidity',hue='rainfall',fill=True,common_norm=False);" ] }, { "cell_type": "markdown", "id": "a6bcff29-a9c8-4a57-b34d-411d868e59c1", "metadata": {}, "source": [ "The KDE plot shows that rainy days are associated with clearly higher humidity values, with a noticeable right-shift of the distribution compared to non-rainy days, indicating strong predictive potential." ] }, { "cell_type": "code", "execution_count": 16, "id": "73927b25-b1dc-4eba-aa47-c2a7eed8b914", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "rainfall\n", "1 0.753425\n", "0 0.246575\n", "Name: proportion, dtype: float64" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1['rainfall'].value_counts(normalize=True)" ] }, { "cell_type": "code", "execution_count": 31, "id": "006dfece-bb09-45d2-b011-79c09412e2d5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(5,4))\n", "sns.countplot(x='rainfall', data=df1)\n", "plt.title('Target Distribution')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "88e1692a-a276-402c-905a-97acb9025db2", "metadata": {}, "source": [ "The target variable is imbalanced, with approximately 75% rainy days and 25% non-rainy days, making ROC-AUC an appropriate evaluation metric." ] }, { "cell_type": "code", "execution_count": 17, "id": "26cc4f58-25d2-4c72-acaa-69a9e57e8427", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
countmeanstdmin25%50%75%max
id2190.01094.500000632.3428660.0547.2501094.501641.7502189.0
day2190.0179.948402105.2035921.089.000178.50270.000365.0
pressure2190.01013.6021465.655366999.01008.6001013.001017.7751034.6
maxtemp2190.026.3657995.65433010.421.30027.8031.20036.0
temparature2190.023.9530595.2224107.419.30025.5028.40031.5
mintemp2190.022.1700915.0591204.017.70023.8526.40029.8
dewpoint2190.020.4545665.288406-0.316.80022.1525.00026.7
humidity2190.082.0365307.80065439.077.00082.0088.00098.0
cloud2190.075.72191818.0264982.069.00083.0088.000100.0
sunshine2190.03.7444293.6263270.00.4002.406.80012.1
winddirection2190.0104.86315180.00241610.040.00070.00200.000300.0
windspeed2190.021.8047039.8986594.414.12520.5027.90059.5
rainfall2190.00.7534250.4311160.01.0001.001.0001.0
\n", "
" ], "text/plain": [ " count mean std min 25% 50% \\\n", "id 2190.0 1094.500000 632.342866 0.0 547.250 1094.50 \n", "day 2190.0 179.948402 105.203592 1.0 89.000 178.50 \n", "pressure 2190.0 1013.602146 5.655366 999.0 1008.600 1013.00 \n", "maxtemp 2190.0 26.365799 5.654330 10.4 21.300 27.80 \n", "temparature 2190.0 23.953059 5.222410 7.4 19.300 25.50 \n", "mintemp 2190.0 22.170091 5.059120 4.0 17.700 23.85 \n", "dewpoint 2190.0 20.454566 5.288406 -0.3 16.800 22.15 \n", "humidity 2190.0 82.036530 7.800654 39.0 77.000 82.00 \n", "cloud 2190.0 75.721918 18.026498 2.0 69.000 83.00 \n", "sunshine 2190.0 3.744429 3.626327 0.0 0.400 2.40 \n", "winddirection 2190.0 104.863151 80.002416 10.0 40.000 70.00 \n", "windspeed 2190.0 21.804703 9.898659 4.4 14.125 20.50 \n", "rainfall 2190.0 0.753425 0.431116 0.0 1.000 1.00 \n", "\n", " 75% max \n", "id 1641.750 2189.0 \n", "day 270.000 365.0 \n", "pressure 1017.775 1034.6 \n", "maxtemp 31.200 36.0 \n", "temparature 28.400 31.5 \n", "mintemp 26.400 29.8 \n", "dewpoint 25.000 26.7 \n", "humidity 88.000 98.0 \n", "cloud 88.000 100.0 \n", "sunshine 6.800 12.1 \n", "winddirection 200.000 300.0 \n", "windspeed 27.900 59.5 \n", "rainfall 1.000 1.0 " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df1.describe().T" ] }, { "cell_type": "code", "execution_count": 18, "id": "81347dea-1eef-4142-bf4c-297f8eee6a76", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sns.boxplot(data=df1,x='rainfall',y='humidity')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 19, "id": "caa73444-5f46-4025-acae-2c89175d5025", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
countmeanstdmin25%50%75%max
id730.02554.500000210.8771362190.02372.2502554.502736.7502919.0
day730.0183.000000105.4382711.092.000183.00274.000365.0
pressure730.01013.5030145.5058711000.01008.7251012.701017.6001032.2
maxtemp730.026.3724665.6725217.421.60027.8031.00035.8
temparature730.023.9632885.2780985.919.82525.6528.37531.8
mintemp730.022.1102745.1707444.217.82523.9026.40029.1
dewpoint730.020.4601375.391169-0.016.80022.3025.00026.7
humidity730.082.6698637.81871439.077.25082.0089.00098.0
cloud730.076.36027417.9341210.069.00083.0088.000100.0
sunshine730.03.6643843.6392720.00.3252.206.67511.8
winddirection729.0103.92318281.69545810.040.00070.00200.000300.0
windspeed730.022.4842479.9547794.514.50021.3028.40059.5
\n", "
" ], "text/plain": [ " count mean std min 25% 50% \\\n", "id 730.0 2554.500000 210.877136 2190.0 2372.250 2554.50 \n", "day 730.0 183.000000 105.438271 1.0 92.000 183.00 \n", "pressure 730.0 1013.503014 5.505871 1000.0 1008.725 1012.70 \n", "maxtemp 730.0 26.372466 5.672521 7.4 21.600 27.80 \n", "temparature 730.0 23.963288 5.278098 5.9 19.825 25.65 \n", "mintemp 730.0 22.110274 5.170744 4.2 17.825 23.90 \n", "dewpoint 730.0 20.460137 5.391169 -0.0 16.800 22.30 \n", "humidity 730.0 82.669863 7.818714 39.0 77.250 82.00 \n", "cloud 730.0 76.360274 17.934121 0.0 69.000 83.00 \n", "sunshine 730.0 3.664384 3.639272 0.0 0.325 2.20 \n", "winddirection 729.0 103.923182 81.695458 10.0 40.000 70.00 \n", "windspeed 730.0 22.484247 9.954779 4.5 14.500 21.30 \n", "\n", " 75% max \n", "id 2736.750 2919.0 \n", "day 274.000 365.0 \n", "pressure 1017.600 1032.2 \n", "maxtemp 31.000 35.8 \n", "temparature 28.375 31.8 \n", "mintemp 26.400 29.1 \n", "dewpoint 25.000 26.7 \n", "humidity 89.000 98.0 \n", "cloud 88.000 100.0 \n", "sunshine 6.675 11.8 \n", "winddirection 200.000 300.0 \n", "windspeed 28.400 59.5 " ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2.describe().T" ] }, { "cell_type": "markdown", "id": "0519fa14-897b-4e88-b089-1c9313e678db", "metadata": {}, "source": [ "### Feature Engineering" ] }, { "cell_type": "code", "execution_count": 20, "id": "992bf85e-47f4-42bb-a046-6b96d24b66d0", "metadata": {}, "outputs": [], "source": [ "median=df1['winddirection'].median()\n", "df2['winddirection']=df2['winddirection'].fillna(median)" ] }, { "cell_type": "code", "execution_count": 21, "id": "0da1fcaf-1d6e-43fa-a229-e34eebbb6ea4", "metadata": {}, "outputs": [], "source": [ "def add_features(df):\n", "\n", " # Temperature variability\n", " df['temp_range']=df['maxtemp'] - df['mintemp']\n", " # Air saturation level\n", " df['humidity_gap'] = df['humidity'] - df['dewpoint']\n", " # Sunshine vs. Cloud\n", " df['sunshine_ratio']=df['sunshine'] / (df['cloud'] + 1)\n", " # Wind intensity\n", " df['wind_energy']=df['windspeed'] * df['winddirection']\n", " # Saisonale Features\n", " df['sin_day']=np.sin(2 * np.pi * df['day'] / 365)\n", " df['cos_day']=np.cos(2 * np.pi * df['day'] / 365)\n", "\n", " return df" ] }, { "cell_type": "code", "execution_count": 24, "id": "e5991e8f-3114-4b39-8c25-725d971365e0", "metadata": {}, "outputs": [], "source": [ "df1=add_features(df1)\n", "df2=add_features(df2)" ] }, { "cell_type": "markdown", "id": "010ac0c4-4571-4b5b-bb2d-4c4bfbdadf5c", "metadata": {}, "source": [ "### Modelling" ] }, { "cell_type": "code", "execution_count": 25, "id": "aeb1a3ad-ae09-411d-84d8-1e700c276498", "metadata": {}, "outputs": [], "source": [ "x=df1.drop(['rainfall','id'],axis=1)" ] }, { "cell_type": "code", "execution_count": 26, "id": "e84b71a3-9081-438c-afd4-6ff58b267d1a", "metadata": {}, "outputs": [], "source": [ "y=df1[['rainfall']]" ] }, { "cell_type": "code", "execution_count": 27, "id": "bb924891-7388-4009-a66c-d7fc6064280e", "metadata": {}, "outputs": [], "source": [ "x_train,x_val, y_train, y_val=train_test_split(x,y, test_size=.20, random_state=42, stratify=y)" ] }, { "cell_type": "markdown", "id": "c2b3dbc2-2a54-426c-91f6-23b713313cfd", "metadata": {}, "source": [ "### 1th LogisticRegression" ] }, { "cell_type": "code", "execution_count": 32, "id": "163ed19c-2526-480b-b089-04d67a93563f", "metadata": {}, "outputs": [], "source": [ "lr=LogisticRegression(max_iter=1000,class_weight='balanced',n_jobs=-1)" ] }, { "cell_type": "code", "execution_count": 33, "id": "7d0e78e1-8a96-4cff-8a5d-78d862e7723a", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
LogisticRegression(class_weight='balanced', max_iter=1000, n_jobs=-1)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LogisticRegression(class_weight='balanced', max_iter=1000, n_jobs=-1)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lr.fit(x_train,y_train)" ] }, { "cell_type": "code", "execution_count": 34, "id": "fbb53f48-2a20-4b1e-8d36-3d1137d06947", "metadata": {}, "outputs": [], "source": [ "lrtahmin=lr.predict(x_val)" ] }, { "cell_type": "code", "execution_count": 35, "id": "2f365622-e02d-4842-8a33-3798bc3cd028", "metadata": {}, "outputs": [], "source": [ "y_val_proba=lr.predict_proba(x_val)[:, 1]" ] }, { "cell_type": "code", "execution_count": 36, "id": "d02db6f4-8f05-41f4-8065-a78f7de30432", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ROC AUC: 0.8804\n" ] } ], "source": [ "roc_auc=roc_auc_score(y_val, y_val_proba)\n", "print(f\"ROC AUC: {roc_auc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 37, "id": "864c7b94-e7cf-455f-b5aa-557a5a20a646", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.8425\n" ] } ], "source": [ "acc=accuracy_score(y_val, lrtahmin)\n", "print(f\"Accuracy: {acc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 38, "id": "fa6a703b-a982-4246-b7ae-13e9e91cf922", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 81, 27],\n", " [ 42, 288]])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_val, lrtahmin)" ] }, { "cell_type": "code", "execution_count": 39, "id": "65cf7610-858b-4176-bace-88a435b82a67", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.66 0.75 0.70 108\n", " 1 0.91 0.87 0.89 330\n", "\n", " accuracy 0.84 438\n", " macro avg 0.79 0.81 0.80 438\n", "weighted avg 0.85 0.84 0.85 438\n", "\n" ] } ], "source": [ "print(\"\\nClassification Report:\")\n", "print(classification_report(y_val, lrtahmin))" ] }, { "cell_type": "code", "execution_count": 42, "id": "05bba194-cad2-48c5-b4e8-8d13e400efad", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fpr, tpr, thresholds=roc_curve(y_val, y_val_proba)\n", "roc_auc=auc(fpr, tpr)\n", "\n", "plt.figure(figsize=(6,5))\n", "plt.plot(fpr, tpr, label=f'Logistic Regression (AUC = {roc_auc:.3f})')\n", "plt.plot([0, 1], [0, 1], 'k--', label='Random Classifier')\n", "\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('ROC Curve')\n", "plt.legend(loc='lower right')\n", "plt.grid(alpha=0.3)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 43, "id": "27f8acd4-038d-4744-8a5c-b7f7522d9abb", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cm=confusion_matrix(y_val, lrtahmin).astype(int)\n", "\n", "sns.heatmap(cm, annot=True, fmt='d')\n", "plt.show();" ] }, { "cell_type": "code", "execution_count": 46, "id": "7ca4a2df-8974-4ad8-a014-57ad0e1e091e", "metadata": {}, "outputs": [], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.neighbors import KNeighborsClassifier\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.ensemble import AdaBoostClassifier\n", "from sklearn.ensemble import GradientBoostingClassifier\n", "from sklearn.naive_bayes import MultinomialNB\n", "from sklearn.naive_bayes import BernoulliNB\n", "\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score\n", "from sklearn.metrics import f1_score, confusion_matrix, classification_report\n", "from sklearn.model_selection import train_test_split\n", "\n", "b = BernoulliNB()\n", "l = LogisticRegression()\n", "d = DecisionTreeClassifier()\n", "r = RandomForestClassifier()\n", "gb= GradientBoostingClassifier()\n", "kn= KNeighborsClassifier()\n", "ab= AdaBoostClassifier()\n", "\n", "def algo_test(x, y):\n", " modeller=[ b, l, d, r, gb, kn, ab]\n", " isimler=[\"BernoulliNB\", \"LogisticRegression\", \"DecisionTreeClassifier\", \n", " \"RandomForestClassifier\", \"GradientBoostingClassifier\", \"KNeighborsClassifier\",\n", " \"AdaBoostClassifier\"]\n", "\n", " x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.3, random_state = 42)\n", " \n", " accuracy = []\n", " precision = []\n", " recall = []\n", " f1 = []\n", " mdl=[]\n", "\n", " print(\"Veriler hazır modeller deneniyor\")\n", " for model in modeller:\n", " print(model, \" modeli eğitiliyor!..\")\n", " model=model.fit(x_train,y_train)\n", " tahmin=model.predict(x_test)\n", " mdl.append(model)\n", " accuracy.append(accuracy_score(y_test, tahmin))\n", " precision.append(precision_score(y_test, tahmin, average=\"micro\"))\n", " recall.append(recall_score(y_test, tahmin, average=\"micro\"))\n", " f1.append(f1_score(y_test, tahmin, average=\"micro\"))\n", " print(confusion_matrix(y_test, tahmin))\n", "\n", " print(\"Eğitim tamamlandı.\")\n", " \n", " metrics=pd.DataFrame(columns=[\"Accuracy\", \"Precision\", \"Recall\", \"F1\", \"Model\"], index=isimler)\n", " metrics[\"Accuracy\"] = accuracy\n", " metrics[\"Precision\"] = precision \n", " metrics[\"Recall\"] = recall\n", " metrics[\"F1\"] = f1\n", " metrics[\"Model\"]=mdl\n", "\n", " metrics.sort_values(\"F1\", ascending=False, inplace=True)\n", "\n", " print(\"En başarılı model: \", metrics.iloc[0].name)\n", " model=metrics.iloc[0,-1]\n", " tahmin=model.predict(np.array(x_test) if model==kn else x_test)\n", " print(\"Confusion Matrix:\")\n", " print(confusion_matrix(y_test, tahmin))\n", " print(\"classification Report:\")\n", " print(classification_report(y_test, tahmin))\n", " print(\"Diğer Modeller:\")\n", " \n", " return metrics.drop(\"Model\", axis=1)" ] }, { "cell_type": "code", "execution_count": 47, "id": "55a49924-6776-4c8b-878f-0551171be667", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Veriler hazır modeller deneniyor\n", "BernoulliNB() modeli eğitiliyor!..\n", "[[ 0 167]\n", " [ 0 490]]\n", "LogisticRegression() modeli eğitiliyor!..\n", "[[105 62]\n", " [ 30 460]]\n", "DecisionTreeClassifier() modeli eğitiliyor!..\n", "[[ 94 73]\n", " [ 56 434]]\n", "RandomForestClassifier() modeli eğitiliyor!..\n", "[[102 65]\n", " [ 36 454]]\n", "GradientBoostingClassifier() modeli eğitiliyor!..\n", "[[ 98 69]\n", " [ 33 457]]\n", "KNeighborsClassifier() modeli eğitiliyor!..\n", "[[ 51 116]\n", " [ 30 460]]\n", "AdaBoostClassifier() modeli eğitiliyor!..\n", "[[111 56]\n", " [ 46 444]]\n", "Eğitim tamamlandı.\n", "En başarılı model: LogisticRegression\n", "Confusion Matrix:\n", "[[105 62]\n", " [ 30 460]]\n", "classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.78 0.63 0.70 167\n", " 1 0.88 0.94 0.91 490\n", "\n", " accuracy 0.86 657\n", " macro avg 0.83 0.78 0.80 657\n", "weighted avg 0.85 0.86 0.85 657\n", "\n", "Diğer Modeller:\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
AccuracyPrecisionRecallF1
LogisticRegression0.8599700.8599700.8599700.859970
RandomForestClassifier0.8462710.8462710.8462710.846271
GradientBoostingClassifier0.8447490.8447490.8447490.844749
AdaBoostClassifier0.8447490.8447490.8447490.844749
DecisionTreeClassifier0.8036530.8036530.8036530.803653
KNeighborsClassifier0.7777780.7777780.7777780.777778
BernoulliNB0.7458140.7458140.7458140.745814
\n", "
" ], "text/plain": [ " Accuracy Precision Recall F1\n", "LogisticRegression 0.859970 0.859970 0.859970 0.859970\n", "RandomForestClassifier 0.846271 0.846271 0.846271 0.846271\n", "GradientBoostingClassifier 0.844749 0.844749 0.844749 0.844749\n", "AdaBoostClassifier 0.844749 0.844749 0.844749 0.844749\n", "DecisionTreeClassifier 0.803653 0.803653 0.803653 0.803653\n", "KNeighborsClassifier 0.777778 0.777778 0.777778 0.777778\n", "BernoulliNB 0.745814 0.745814 0.745814 0.745814" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "algo_test(x,y)" ] }, { "cell_type": "markdown", "id": "b48abc85-0a88-4398-8bfa-7245324ca082", "metadata": {}, "source": [ "### 2th XGBClassifier" ] }, { "cell_type": "code", "execution_count": 59, "id": "da821a02-f3ab-4698-9106-7b2762e88eb4", "metadata": {}, "outputs": [], "source": [ "xg=XGBClassifier(\n", " n_estimators=2000,\n", " learning_rate=0.03,\n", " max_depth=4,\n", " min_child_weight=5,\n", " subsample=0.8,\n", " colsample_bytree=0.8,\n", " reg_alpha=0.0,\n", " reg_lambda=1.0,\n", " gamma=0.0,\n", " objective='binary:logistic',\n", " eval_metric='auc',\n", " tree_method='hist',\n", " random_state=42,\n", " n_jobs=-1)" ] }, { "cell_type": "code", "execution_count": 60, "id": "9e1c16c9-dd3b-4465-8b81-b22d9125ebdd", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
       "              colsample_bylevel=None, colsample_bynode=None,\n",
       "              colsample_bytree=0.8, device=None, early_stopping_rounds=None,\n",
       "              enable_categorical=False, eval_metric='auc', feature_types=None,\n",
       "              feature_weights=None, gamma=0.0, grow_policy=None,\n",
       "              importance_type=None, interaction_constraints=None,\n",
       "              learning_rate=0.03, max_bin=None, max_cat_threshold=None,\n",
       "              max_cat_to_onehot=None, max_delta_step=None, max_depth=4,\n",
       "              max_leaves=None, min_child_weight=5, missing=nan,\n",
       "              monotone_constraints=None, multi_strategy=None, n_estimators=2000,\n",
       "              n_jobs=-1, num_parallel_tree=None, ...)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "XGBClassifier(base_score=None, booster=None, callbacks=None,\n", " colsample_bylevel=None, colsample_bynode=None,\n", " colsample_bytree=0.8, device=None, early_stopping_rounds=None,\n", " enable_categorical=False, eval_metric='auc', feature_types=None,\n", " feature_weights=None, gamma=0.0, grow_policy=None,\n", " importance_type=None, interaction_constraints=None,\n", " learning_rate=0.03, max_bin=None, max_cat_threshold=None,\n", " max_cat_to_onehot=None, max_delta_step=None, max_depth=4,\n", " max_leaves=None, min_child_weight=5, missing=nan,\n", " monotone_constraints=None, multi_strategy=None, n_estimators=2000,\n", " n_jobs=-1, num_parallel_tree=None, ...)" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "xg.fit(x_train,y_train)" ] }, { "cell_type": "code", "execution_count": 61, "id": "650fbb69-2f4d-4db9-8b14-63bb9bc69699", "metadata": {}, "outputs": [], "source": [ "xgtahmin=xg.predict(x_val)" ] }, { "cell_type": "code", "execution_count": 62, "id": "a43ecfc2-121e-4ff6-a994-6c2a4c69b937", "metadata": {}, "outputs": [], "source": [ "y_proba_xg=xg.predict_proba(x_val)[:, 1]" ] }, { "cell_type": "code", "execution_count": 63, "id": "cc3addd2-d923-4ba3-bfe7-3d2dfa9b7c60", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ROC AUC: 0.8516\n" ] } ], "source": [ "roc_auc=roc_auc_score(y_val, y_proba_xg)\n", "print(f\"ROC AUC: {roc_auc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 64, "id": "5ec53cd7-59f0-46f1-9505-09696959cc21", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.8447\n" ] } ], "source": [ "acc=accuracy_score(y_val, xgtahmin)\n", "print(f\"Accuracy: {acc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 65, "id": "83b835e6-a07a-40ac-9fe0-9560ab76977b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 68, 40],\n", " [ 28, 302]])" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_val, xgtahmin)" ] }, { "cell_type": "code", "execution_count": 66, "id": "d4fcfa0e-d954-42f7-9c75-5c78c51003d3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.71 0.63 0.67 108\n", " 1 0.88 0.92 0.90 330\n", "\n", " accuracy 0.84 438\n", " macro avg 0.80 0.77 0.78 438\n", "weighted avg 0.84 0.84 0.84 438\n", "\n" ] } ], "source": [ "print(\"\\nClassification Report:\")\n", "print(classification_report(y_val, xgtahmin))" ] }, { "cell_type": "code", "execution_count": 67, "id": "0d7e9cad-31fa-4a8b-934c-7316b79f2309", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fpr, tpr, thresholds=roc_curve(y_val, y_proba_xg)\n", "roc_auc=auc(fpr, tpr)\n", "\n", "plt.figure(figsize=(6,5))\n", "plt.plot(fpr, tpr, label=f'Logistic Regression (AUC = {roc_auc:.3f})')\n", "plt.plot([0, 1], [0, 1], 'k--', label='Random Classifier')\n", "\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('ROC Curve')\n", "plt.legend(loc='lower right')\n", "plt.grid(alpha=0.3)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a27b8c65-0324-4ca5-bae6-703cf7de84ee", "metadata": {}, "source": [ "### 3th CatBoostClassifier" ] }, { "cell_type": "code", "execution_count": 68, "id": "2a0326f3-8553-4aad-9223-aa5af132e9a2", "metadata": {}, "outputs": [], "source": [ "cb=CatBoostClassifier(iterations=5000,\n", " learning_rate=0.03,\n", " depth=6,\n", " l2_leaf_reg=3.0,\n", " loss_function='Logloss',\n", " eval_metric='AUC',\n", " random_seed=42,\n", " verbose=0)" ] }, { "cell_type": "code", "execution_count": 70, "id": "6d1fa588-92b0-4aed-900a-7e0b9f5be5ed", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cb.fit(x_train,y_train)" ] }, { "cell_type": "code", "execution_count": 71, "id": "7c21ab0f-cbcf-4098-9be2-26903e438ac3", "metadata": {}, "outputs": [], "source": [ "cbtahmin=cb.predict(x_val)" ] }, { "cell_type": "code", "execution_count": 72, "id": "ffce99fe-beec-485b-a135-669d1d2904ee", "metadata": {}, "outputs": [], "source": [ "y_proba_cb=cb.predict_proba(x_val)[:, 1]" ] }, { "cell_type": "code", "execution_count": 73, "id": "e7632ffc-123c-4359-ae7f-61c8f0d2f323", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ROC AUC: 0.8616\n" ] } ], "source": [ "roc_auc=roc_auc_score(y_val, y_proba_cb)\n", "print(f\"ROC AUC: {roc_auc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 74, "id": "e8e60398-6688-4512-aabd-eb00b3581639", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.8402\n" ] } ], "source": [ "acc=accuracy_score(y_val, cbtahmin)\n", "print(f\"Accuracy: {acc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 75, "id": "61593263-dbb2-44de-91de-79b5aa784845", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 63, 45],\n", " [ 25, 305]])" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_val, cbtahmin)" ] }, { "cell_type": "code", "execution_count": 76, "id": "ffc1374c-1c59-4c61-8b28-90f53a5304f0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.72 0.58 0.64 108\n", " 1 0.87 0.92 0.90 330\n", "\n", " accuracy 0.84 438\n", " macro avg 0.79 0.75 0.77 438\n", "weighted avg 0.83 0.84 0.83 438\n", "\n" ] } ], "source": [ "print(\"\\nClassification Report:\")\n", "print(classification_report(y_val, cbtahmin))" ] }, { "cell_type": "code", "execution_count": 77, "id": "be85fd8c-65da-4eba-a16d-fac9369564aa", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fpr, tpr, thresholds=roc_curve(y_val, y_proba_cb)\n", "roc_auc=auc(fpr, tpr)\n", "\n", "plt.figure(figsize=(6,5))\n", "plt.plot(fpr, tpr, label=f'Logistic Regression (AUC = {roc_auc:.3f})')\n", "plt.plot([0, 1], [0, 1], 'k--', label='Random Classifier')\n", "\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('ROC Curve')\n", "plt.legend(loc='lower right')\n", "plt.grid(alpha=0.3)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "d2e52575-e401-45e3-86cd-ed104e4b205e", "metadata": {}, "source": [ "### 4th LGBMClassifier" ] }, { "cell_type": "code", "execution_count": 83, "id": "7fdbb1fa-3f18-493c-a08a-c27d8df761b4", "metadata": {}, "outputs": [], "source": [ "lg=LGBMClassifier(\n", " n_estimators=5000,\n", " learning_rate=0.03,\n", " num_leaves=31,\n", " max_depth=-1,\n", " min_child_samples=20,\n", " subsample=0.8,\n", " colsample_bytree=0.8,\n", " reg_alpha=0.0,\n", " reg_lambda=0.0,\n", " random_state=42,\n", " n_jobs=-1\n", ")" ] }, { "cell_type": "code", "execution_count": 84, "id": "81c24bff-ea26-4586-958e-fdf1e2076c34", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[LightGBM] [Info] Number of positive: 1320, number of negative: 432\n", "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000695 seconds.\n", "You can set `force_col_wise=true` to remove the overhead.\n", "[LightGBM] [Info] Total Bins 2967\n", "[LightGBM] [Info] Number of data points in the train set: 1752, number of used features: 17\n", "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.753425 -> initscore=1.116961\n", "[LightGBM] [Info] Start training from score 1.116961\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n" ] }, { "data": { "text/html": [ "
LGBMClassifier(colsample_bytree=0.8, learning_rate=0.03, n_estimators=5000,\n",
       "               n_jobs=-1, random_state=42, subsample=0.8)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LGBMClassifier(colsample_bytree=0.8, learning_rate=0.03, n_estimators=5000,\n", " n_jobs=-1, random_state=42, subsample=0.8)" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lg.fit(x_train,y_train)" ] }, { "cell_type": "code", "execution_count": 85, "id": "d7ebe36f-d2ce-4658-ad9c-fc00dbc7cac3", "metadata": {}, "outputs": [], "source": [ "lgtahmin=lg.predict(x_val)" ] }, { "cell_type": "code", "execution_count": 86, "id": "ecc02a36-c4e4-4917-b4d9-c2a4e50e102a", "metadata": {}, "outputs": [], "source": [ "y_proba_lg=lg.predict_proba(x_val)[:, 1]" ] }, { "cell_type": "code", "execution_count": 87, "id": "e7811f7b-f3f7-4401-94c4-14ba0baa624e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ROC AUC: 0.8535\n" ] } ], "source": [ "roc_auc=roc_auc_score(y_val, y_proba_lg)\n", "print(f\"ROC AUC: {roc_auc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 88, "id": "7851b96e-0885-4704-a358-476ceeb50453", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.8470\n" ] } ], "source": [ "acc=accuracy_score(y_val, lgtahmin)\n", "print(f\"Accuracy: {acc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 89, "id": "5eed7bc9-a72b-42e0-8f42-b7b863e72e13", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 65, 43],\n", " [ 24, 306]])" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_val, lgtahmin)" ] }, { "cell_type": "code", "execution_count": 90, "id": "95f034ca-0fde-4fa5-b95b-2b96f243c5e2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.73 0.60 0.66 108\n", " 1 0.88 0.93 0.90 330\n", "\n", " accuracy 0.85 438\n", " macro avg 0.80 0.76 0.78 438\n", "weighted avg 0.84 0.85 0.84 438\n", "\n" ] } ], "source": [ "print(\"\\nClassification Report:\")\n", "print(classification_report(y_val, lgtahmin))" ] }, { "cell_type": "code", "execution_count": 91, "id": "9bca057b-0a5e-4523-ad02-57377cf0cc80", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fpr, tpr, thresholds=roc_curve(y_val, y_proba_lg)\n", "roc_auc=auc(fpr, tpr)\n", "\n", "plt.figure(figsize=(6,5))\n", "plt.plot(fpr, tpr, label=f'Logistic Regression (AUC = {roc_auc:.3f})')\n", "plt.plot([0, 1], [0, 1], 'k--', label='Random Classifier')\n", "\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('ROC Curve')\n", "plt.legend(loc='lower right')\n", "plt.grid(alpha=0.3)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "cf52efa8-ea58-4576-950e-674c4fd249b3", "metadata": {}, "source": [ "### 5th AdaBoostClassifier" ] }, { "cell_type": "code", "execution_count": 92, "id": "c7b669e3-01ea-4095-b391-7b89834d3dcd", "metadata": {}, "outputs": [], "source": [ "ab=AdaBoostClassifier(estimator=DecisionTreeClassifier(max_depth=2, random_state=42),n_estimators=400,learning_rate=0.05,random_state=42)" ] }, { "cell_type": "code", "execution_count": 93, "id": "7078e457-49b8-4b2e-9147-d93987eefc4c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
AdaBoostClassifier(estimator=DecisionTreeClassifier(max_depth=2,\n",
       "                                                    random_state=42),\n",
       "                   learning_rate=0.05, n_estimators=400, random_state=42)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "AdaBoostClassifier(estimator=DecisionTreeClassifier(max_depth=2,\n", " random_state=42),\n", " learning_rate=0.05, n_estimators=400, random_state=42)" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ab.fit(x_train,y_train)" ] }, { "cell_type": "code", "execution_count": 94, "id": "3a71443e-172e-4b98-a311-0cf72a5980c7", "metadata": {}, "outputs": [], "source": [ "abtahmin=ab.predict(x_val)" ] }, { "cell_type": "code", "execution_count": 95, "id": "efc1a13f-b3b4-45e2-a5e1-4e3cb63ec26f", "metadata": {}, "outputs": [], "source": [ "y_proba_ab=ab.predict_proba(x_val)[:, 1]" ] }, { "cell_type": "code", "execution_count": 96, "id": "380d15a0-9ee4-4241-a94d-d41072ac0c39", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ROC AUC: 0.8743\n" ] } ], "source": [ "roc_auc=roc_auc_score(y_val, y_proba_ab)\n", "print(f\"ROC AUC: {roc_auc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 97, "id": "d5f59412-62af-4cb4-a898-bc797f007e87", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.8767\n" ] } ], "source": [ "acc=accuracy_score(y_val, abtahmin)\n", "print(f\"Accuracy: {acc:.4f}\")" ] }, { "cell_type": "code", "execution_count": 98, "id": "9f120140-27a9-461b-b00f-210c84cb90b0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 71, 37],\n", " [ 17, 313]])" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "confusion_matrix(y_val, abtahmin)" ] }, { "cell_type": "code", "execution_count": 99, "id": "e1b49c46-57b0-49cd-9586-c7f6d0b4d296", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.81 0.66 0.72 108\n", " 1 0.89 0.95 0.92 330\n", "\n", " accuracy 0.88 438\n", " macro avg 0.85 0.80 0.82 438\n", "weighted avg 0.87 0.88 0.87 438\n", "\n" ] } ], "source": [ "print(\"\\nClassification Report:\")\n", "print(classification_report(y_val, abtahmin))" ] }, { "cell_type": "code", "execution_count": 100, "id": "c107239d-5ea0-4ca2-8887-eb735cf1b7d4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fpr, tpr, thresholds=roc_curve(y_val, y_proba_ab)\n", "roc_auc=auc(fpr, tpr)\n", "\n", "plt.figure(figsize=(6,5))\n", "plt.plot(fpr, tpr, label=f'Logistic Regression (AUC = {roc_auc:.3f})')\n", "plt.plot([0, 1], [0, 1], 'k--', label='Random Classifier')\n", "\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('ROC Curve')\n", "plt.legend(loc='lower right')\n", "plt.grid(alpha=0.3)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "f1252f44-96ca-4f2e-b2ac-2977c2aa6d89", "metadata": {}, "source": [ "### Test" ] }, { "cell_type": "code", "execution_count": 109, "id": "9c2d1c71-be6a-4060-9be9-9a6ddd00fbdf", "metadata": {}, "outputs": [], "source": [ "sub=pd.read_csv('sample_submission.csv')" ] }, { "cell_type": "code", "execution_count": 110, "id": "fb3933eb-c1b2-40e5-a54b-ae84cdfa7e32", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idrainfall
021900
121910
221920
321930
421940
\n", "
" ], "text/plain": [ " id rainfall\n", "0 2190 0\n", "1 2191 0\n", "2 2192 0\n", "3 2193 0\n", "4 2194 0" ] }, "execution_count": 110, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sub.head()" ] }, { "cell_type": "code", "execution_count": 124, "id": "98053c2c-c3d3-4218-a1f8-c91dd2a1c10e", "metadata": {}, "outputs": [], "source": [ "x_test=df2.drop(['id'],axis=1)" ] }, { "cell_type": "code", "execution_count": 125, "id": "d0fb5206-4da9-4928-b2d6-1fee3e4caa4e", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
daypressuremaxtemptemparaturemintempdewpointhumiditycloudsunshinewinddirectionwindspeedtemp_rangehumidity_gapsunshine_ratiowind_energysin_daycos_day
011019.517.515.812.714.996.099.00.050.024.34.881.10.0000001215.00.0172130.999852
121016.517.516.515.815.197.099.00.050.035.31.781.90.0000001765.00.0344220.999407
231023.911.210.49.48.986.096.00.040.016.91.877.10.000000676.00.0516200.998667
341022.920.617.315.29.575.045.07.120.050.65.465.50.1543481012.00.0688020.997630
451022.216.113.86.44.368.049.09.220.019.49.763.70.184000388.00.0859650.996298
\n", "
" ], "text/plain": [ " day pressure maxtemp temparature mintemp dewpoint humidity cloud \\\n", "0 1 1019.5 17.5 15.8 12.7 14.9 96.0 99.0 \n", "1 2 1016.5 17.5 16.5 15.8 15.1 97.0 99.0 \n", "2 3 1023.9 11.2 10.4 9.4 8.9 86.0 96.0 \n", "3 4 1022.9 20.6 17.3 15.2 9.5 75.0 45.0 \n", "4 5 1022.2 16.1 13.8 6.4 4.3 68.0 49.0 \n", "\n", " sunshine winddirection windspeed temp_range humidity_gap \\\n", "0 0.0 50.0 24.3 4.8 81.1 \n", "1 0.0 50.0 35.3 1.7 81.9 \n", "2 0.0 40.0 16.9 1.8 77.1 \n", "3 7.1 20.0 50.6 5.4 65.5 \n", "4 9.2 20.0 19.4 9.7 63.7 \n", "\n", " sunshine_ratio wind_energy sin_day cos_day \n", "0 0.000000 1215.0 0.017213 0.999852 \n", "1 0.000000 1765.0 0.034422 0.999407 \n", "2 0.000000 676.0 0.051620 0.998667 \n", "3 0.154348 1012.0 0.068802 0.997630 \n", "4 0.184000 388.0 0.085965 0.996298 " ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_test.head()" ] }, { "cell_type": "code", "execution_count": 126, "id": "2362f929-857b-4f76-bd9d-09f232d112fa", "metadata": {}, "outputs": [], "source": [ "final_lr=LogisticRegression(max_iter=1000,class_weight='balanced',n_jobs=-1)" ] }, { "cell_type": "code", "execution_count": 127, "id": "026ea9fa-7357-4bee-9d58-58a81034887d", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
LogisticRegression(class_weight='balanced', max_iter=1000, n_jobs=-1)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "LogisticRegression(class_weight='balanced', max_iter=1000, n_jobs=-1)" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "final_lr.fit(x, y)" ] }, { "cell_type": "code", "execution_count": 128, "id": "18eb6a1f-cf96-4314-9ebd-cfc8e142f8c6", "metadata": {}, "outputs": [], "source": [ "test_proba=final_lr.predict_proba(x_test)[:, 1]" ] }, { "cell_type": "code", "execution_count": 129, "id": "ad338f35-473c-4552-88de-790bb4851222", "metadata": {}, "outputs": [], "source": [ "submission=pd.DataFrame({'id': df2['id'],'rainfall': test_proba})" ] }, { "cell_type": "code", "execution_count": 130, "id": "0c7f40c8-76c1-45b4-a1b2-52f07f353f13", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " id rainfall\n", "0 2190 0.958098\n", "1 2191 0.951503\n", "2 2192 0.843682\n", "3 2193 0.028115\n", "4 2194 0.020298\n" ] } ], "source": [ "print(submission.head())" ] }, { "cell_type": "code", "execution_count": 131, "id": "d80d2f11-d226-4e02-8c75-7498d72d3125", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(730, 2)\n" ] } ], "source": [ "print(submission.shape)" ] }, { "cell_type": "code", "execution_count": 132, "id": "039ccaa5-23d3-488d-8ee6-b40e42d01609", "metadata": {}, "outputs": [], "source": [ "submission.to_csv('submission.csv',index=False)" ] }, { "cell_type": "code", "execution_count": 136, "id": "bbbf2947-cafb-4928-a1f3-83e05ccabc27", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['lr_final_model.pkl']" ] }, "execution_count": 136, "metadata": {}, "output_type": "execute_result" } ], "source": [ "joblib.dump(final_lr, 'lr_final_model.pkl')" ] }, { "cell_type": "code", "execution_count": 137, "id": "1b7029b8-0e5d-46cb-a6ca-f6027f2ba314", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['feature_names.pkl']" ] }, "execution_count": 137, "metadata": {}, "output_type": "execute_result" } ], "source": [ "joblib.dump(x_train.columns.tolist(),'feature_names.pkl')" ] }, { "cell_type": "markdown", "id": "ec26707b-79af-4f69-b5ec-38d7ed478721", "metadata": {}, "source": [ "### Conclusion\n", "Several classification models were tested and compared using the ROC-AUC metric.\n", "Logistic Regression achieved the best performance with a ROC-AUC score of 0.88, showing that the relationship between the features and rainfall is largely linear.\n", "The results indicate that the selected features provide strong and meaningful information for predicting rainfall." ] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:base] *", "language": "python", "name": "conda-base-py" }, "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.13.5" } }, "nbformat": 4, "nbformat_minor": 5 }