{

 "cells": [

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "# XGBoost training for lung cancer risk prediction\n",

    "\n",

    "P. Benveniste $^1$, J. Alberge $^1$\n",

    "\n",

    "$^1$ Ecole Normale Supérieure Paris-Saclay\n",

    "\n",

    "In this Notebook, we describe the training of the XGBoost model and hyperparameter optimisation for lung cancer risk prediction using the PLCO and NLST screening trials. "

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "## Library import\n",

    "\n",

    "**YOU NEED TO USE PYTHON 3.7-3.9**"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 75,

   "metadata": {},

   "outputs": [],

   "source": [

    "import pandas as pd\n",

    "import matplotlib.pyplot as plt\n",

    "import pandas as pd\n",

    "import xgboost as xgb\n",

    "import time\n",

    "from time import time\n",

    "import shap\n",

    "import pickle\n",

    "import pprint\n",

    "import numpy as np\n",

    "\n",

    "# Model selection\n",

    "from sklearn.model_selection import StratifiedKFold\n",

    "from sklearn.model_selection import train_test_split\n",

    "\n",

    "# Metrics\n",

    "from sklearn.metrics import brier_score_loss, roc_auc_score, average_precision_score\n",

    "from sklearn.metrics import roc_curve, auc, f1_score, recall_score, precision_recall_curve, precision_score\n",

    "from sklearn.metrics import classification_report, confusion_matrix\n",

    "\n",

    "# Skopt functions\n",

    "from skopt import BayesSearchCV\n",

    "from skopt.callbacks import DeadlineStopper, DeltaYStopper\n",

    "from skopt.space import Real, Integer\n",

    "\n",

    "#Calibration\n",

    "from sklearn.calibration import calibration_curve\n",

    "from sklearn.calibration import CalibratedClassifierCV"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "# Useful functions"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 76,

   "metadata": {},

   "outputs": [],

   "source": [

    "def report_perf(optimizer, X, y, title=\"model\", callbacks=None):\n",

    "    \"\"\"\n",

    "    A wrapper for measuring time and performances of different optmizers\n",

    "    \n",

    "    optimizer = a sklearn or a skopt optimizer\n",

    "    X = the training set \n",

    "    y = our target\n",

    "    title = a string label for the experiment\n",

    "    \"\"\"\n",

    "    start = time()\n",

    "\n",

    "    if callbacks is not None:\n",

    "        optimizer.fit(X, y, callback=callbacks)\n",

    "    else:\n",

    "        optimizer.fit(X, y)\n",

    "        \n",

    "    d=pd.DataFrame(optimizer.cv_results_)\n",

    "    best_score = optimizer.best_score_\n",

    "    best_score_std = d.iloc[optimizer.best_index_].std_test_score\n",

    "    best_params = optimizer.best_params_\n",

    "    \n",

    "    print((title + \" took %.2f seconds,  candidates checked: %d, best CV score: %.3f \"\n",

    "           + u\"\\u00B1\"+\" %.3f\") % (time() - start, \n",

    "                                   len(optimizer.cv_results_['params']),\n",

    "                                   best_score,\n",

    "                                   best_score_std))    \n",

    "    print('Best parameters:')\n",

    "    pprint.pprint(best_params)\n",

    "    print()\n",

    "    return best_params"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "# Lung cancer risk estimation"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "In this notebook, we will try to predict lung cancer based on two datasets: \n",

    "- PLCO dataset: with 150 000 points and 219 descriptors for each point\n",

    "- NLST dataset : 50 000 points and 322 descriptors for each point"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 77,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(154887, 219)\n"

     ]

    },

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "Columns (99,248,249) have mixed types. Specify dtype option on import or set low_memory=False.\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(53452, 324)\n"

     ]

    }

   ],

   "source": [

    "plco_file = './package-plco-594/Lung/lung_data_nov18_d070819.csv'\n",

    "plco = pd.read_csv(plco_file)\n",

    "plco_nb_ini = len(plco)\n",

    "print(plco.shape)\n",

    "\n",

    "nlst_file = './package-nlst-814.2021-07-27/participant_data_d100517.csv'\n",

    "nlst = pd.read_csv(nlst_file)\n",

    "nlst_nb_ini = len(nlst)\n",

    "print(nlst.shape)"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "## Removal of non-smokers\n",

    "\n",

    "Because our target populations and because smoking is such a high contributing risk factor we decide to keep only the participants to PLCO who are smokers or former-smokers. Also, this removes a bias as our testing dataset NLST only contains smokers and former-smokers.\n",

    "\n",

    "`cig_stat == 1 or 2`"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 78,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "Total number of participant to PLCO: 154887\n",

      "Numbers of smokers and former-smokers: 80668\n"

     ]

    }

   ],

   "source": [

    "print(\"Total number of participant to PLCO:\",len(plco))\n",

    "plco = plco.loc[plco.cig_stat > 0]\n",

    "print(\"Numbers of smokers and former-smokers:\",len(plco))"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "## Censored data\n",

    "\n",

    "Both our dataset contains subjects who are not interesting to our study. We decided to remove:\n",

    "\n",

    "- Patients who died because of something else :\n",

    "\n",

    "    Their case can add bias to the model as they might have been more susceptible of developping lung cancer because of having poor health\n",

    "    \n",

    "- Remove all who have not been followed enough through the study\n",

    "\n",

    "    We will explain how the minimum reauired time was computed"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 79,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "---- PLCO ----\n",

      "Removed 24356\n",

      "Remaining 56312\n",

      "Removed 15.73 % of PLCO\n",

      "---- NLST ----\n",

      "Removed 2904\n",

      "Remaining 50548\n",

      "Removed 5.43 % of NLST\n"

     ]

    }

   ],

   "source": [

    "#For PLCO\n",

    "plco_nb = len(plco)\n",

    "plco = plco.loc[plco['d_dthl']!=0]\n",

    "plco_nb_aft = len(plco)\n",

    "print(\"---- PLCO ----\")\n",

    "print(\"Removed \"+ str(plco_nb - plco_nb_aft ))\n",

    "print(\"Remaining \"+str(plco_nb_aft))\n",

    "print(\"Removed \" + str(round((((plco_nb - plco_nb_aft)/plco_nb_ini)*100),2)) + \" % of PLCO\")\n",

    "\n",

    "#For NLST\n",

    "nlst_nb = len(nlst)\n",

    "nlst = nlst.loc[nlst['finaldeathlc']!=0]\n",

    "nlst_nb_aft = len(nlst)\n",

    "print(\"---- NLST ----\")\n",

    "print(\"Removed \"+ str(nlst_nb - nlst_nb_aft ))\n",

    "print(\"Remaining \"+str(nlst_nb_aft))\n",

    "print(\"Removed \" + str(round((((nlst_nb - nlst_nb_aft)/nlst_nb_ini)*100),2)) + \" % of NLST\")\n"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "Let's look at the distribution of the length of study of the patients to select a length which is appropriate for everyone."

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 80,

   "metadata": {},

   "outputs": [

    {

     "data": {

      "image/png": "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",

      "text/plain": [

       "<Figure size 640x480 with 2 Axes>"

      ]

     },

     "metadata": {},

     "output_type": "display_data"

    }

   ],

   "source": [

    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",

    "fig.suptitle('Distribution of length of study in PLCO and NLST ')\n",

    "ax1.boxplot(plco['lung_exitdays'])\n",

    "ax2.boxplot(nlst['fup_days'])\n",

    "plt.show()"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We only keep participant who were studied longer than 2100 days (5.75 years) if they were never diagnosed with cancer and those who were diagnosed with cancer when ever. On the other hand, we don't mind keeping participants who stayed longer as they bring more information to the study. "

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 81,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "---- PLCO ----\n",

      "Removed 1151\n",

      "Remaining 55161\n",

      "Removed 0.74 % of PLCO\n",

      "---- NLST ----\n",

      "Removed 1953\n",

      "Remaining 48595\n",

      "Removed 3.65 % of NLST\n"

     ]

    }

   ],

   "source": [

    "plco_nb2 = len(plco)\n",

    "plco = plco[((plco['lung_exitstat']!=1) & (plco['lung_exitdays']>2100)) | (plco['lung_exitstat']==1)]\n",

    "plco_nb_final = len(plco)\n",

    "print(\"---- PLCO ----\")\n",

    "print(\"Removed \"+ str(plco_nb2 - plco_nb_final ))\n",

    "print(\"Remaining \"+str(plco_nb_final))\n",

    "print(\"Removed \" + str(round((((plco_nb2 - plco_nb_final)/plco_nb_ini)*100),2)) + \" % of PLCO\")\n",

    "\n",

    "nlst_nb2 = len(nlst)\n",

    "nlst = nlst[((nlst['scr_group']!=1) & (nlst['fup_days']>2100)) | (nlst['scr_group']==1)]\n",

    "nlst_nb_final = len(nlst)\n",

    "print(\"---- NLST ----\")\n",

    "print(\"Removed \"+ str(nlst_nb2 - nlst_nb_final ))\n",

    "print(\"Remaining \"+str(nlst_nb_final))\n",

    "print(\"Removed \" + str(round((((nlst_nb2 - nlst_nb_final)/nlst_nb_ini)*100),2)) + \" % of NLST\")\n"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {

    "tags": []

   },

   "source": [

    "## Pre-Processing\n",

    "\n",

    "\n",

    "We first extract the same features from both dataset and keep only those which we have seen are risk factors related to lung cancer.\n",

    "\n",

    "In both dataset, we can find different informations but the dataset may be not be in the same format or described the same descriptors. In the following we will use the name of the PLCO features.\n",

    "\n",

    "\n",

    "For the race feature, On the PLCO dataset, we have: \n",

    "\n",

    "`\n",

    "1=\"White, Non-Hispanic\" \n",

    "2=\"Black, Non-Hispanic\" \n",

    "3=\"Hispanic\"\n",

    "4=\"Asian\"\n",

    "5=\"Pacific Islander\" \n",

    "6=\"American Indian\" \n",

    "7=\"Missing\"\n",

    "`\n",

    "\n",

    "And, for the NLST dataset, we have: \n",

    "\n",

    "`\n",

    "1=\"White\"\n",

    "2=\"Black or African-American\"\n",

    "3=\"Asian\"\n",

    "4=\"American Indian or Alaskan Native\"\n",

    "5=\"Native Hawaiian or Other Pacific Islander\" \n",

    "6=\"More than one race\"\n",

    "7=\"Participant refused to answer\"\n",

    "95=\"Missing data form - form is not expected to ever be completed\"\n",

    "96=\"Missing - no response\"\n",

    "98=\"Missing - form was submitted and the answer was left blank\"\n",

    "99=\"Unknown/ decline to answer\"\n",

    "`\n",

    "\n",

    "So, we will keep: \n",

    "\n",

    "`\n",

    "1=\"White or hispanic\" \n",

    "2=\"Black\" \n",

    "4=\"Asian\"\n",

    "5=\"Pacific Islander\" \n",

    "6=\"American Indian\" \n",

    "7=\"Missing\"\n",

    "`"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 82,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "(55161, 21)\n",

      "(48595, 21)\n"

     ]

    },

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "\n",

      "A value is trying to be set on a copy of a slice from a DataFrame.\n",

      "Try using .loc[row_indexer,col_indexer] = value instead\n",

      "\n",

      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",

      "\n",

      "A value is trying to be set on a copy of a slice from a DataFrame.\n",

      "Try using .loc[row_indexer,col_indexer] = value instead\n",

      "\n",

      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",

      "\n",

      "A value is trying to be set on a copy of a slice from a DataFrame.\n",

      "Try using .loc[row_indexer,col_indexer] = value instead\n",

      "\n",

      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",

      "\n",

      "A value is trying to be set on a copy of a slice from a DataFrame.\n",

      "Try using .loc[row_indexer,col_indexer] = value instead\n",

      "\n",

      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n"

     ]

    }

   ],

   "source": [

    "#For PLCO\n",

    "plco = plco[[\"age\", \"sex\", \"height_f\", \"weight_f\", \"race7\", \"ssmokea_f\", \"cig_stat\", \"cigar\", \"pipe\", \"pack_years\", \"smokea_f\", \"cigpd_f\",\"cig_years\", \"bronchit_f\",\n",

    "                \"diabetes_f\", \"emphys_f\", \"hearta_f\", \"hyperten_f\", \"stroke_f\", \"lung_fh\",\"lung_cancer\"\n",

    "            ]]\n",

    "plco[\"race7\"] = plco[\"race7\"].replace(3,1)\n",

    "plco[\"lung_fh\"] = plco[\"lung_fh\"].replace(9,0)\n",

    "\n",

    "print(plco.shape)\n",

    "\n",

    "#For NLST\n",

    "nlst2 = nlst[[\"age\", \"gender\", \"height\",  \"weight\", \"race\", \"age_quit\", \"cigsmok\", \"cigar\", \"pipe\", \"pkyr\", \"smokeage\", \"smokeday\", \"smokeyr\", \"agechro\", \"diagdiab\",\n",

    "        \"diagemph\", \"diaghear\", \"diaghype\", \"diagstro\",\n",

    "        ]]\n",

    "nlst2[\"lung_fh\"] = nlst[[\"famfather\",\"fammother\", \"famchild\", \"famsister\", \"fambrother\"]].max(axis=1)\n",

    "nlst2[\"can_scr\"] = 1 * (nlst[\"can_scr\"] > 0)\n",

    "nlst2[\"race\"] = nlst2[\"race\"].replace([3,4,6,95,96,98,99],[4,6,7,7,7,7,7])\n",

    "nlst2['cigsmok'] = nlst2[\"cigsmok\"].replace(0,2)\n",

    "nlst=nlst2\n",

    "print(nlst.shape)"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "Now we change the column names to have two matching datasets."

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 83,

   "metadata": {},

   "outputs": [],

   "source": [

    "change_columns = {\n",

    "        \"age\": \"age\",\n",

    "        \"gender\": \"sex\", \n",

    "        \"height\": \"height_f\",\n",

    "        \"weight\": \"weight_f\",\n",

    "        \"race\": \"race7\",\n",

    "        \"age_quit\": \"ssmokea_f\",\n",

    "        \"cigsmok\": \"cig_stat\",\n",

    "        \"cigar\": \"cigar\",\n",

    "        \"pipe\": \"pipe\",\n",

    "        \"pkyr\": \"pack_years\",\n",

    "        \"smokeage\": \"smokea_f\",\n",

    "        \"smokeday\": \"cigpd_f\",\n",

    "        \"smokeyr\": \"cig_years\",\n",

    "        \"agechro\": \"bronchit_f\",\n",

    "        \"diagdiab\": \"diabetes_f\",\n",

    "        \"diagemph\": \"emphys_f\",\n",

    "        \"diaghear\": \"hearta_f\",\n",

    "        \"diaghype\": \"hyperten_f\",\n",

    "        \"diagstro\": \"stroke_f\",\n",

    "        \"can_scr\": \"lung_cancer\",\n",

    "        \"lung_fh\": \"lung_fh\"\n",

    "}\n",

    "nlst = nlst.rename(columns=change_columns)"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We add the `bmi` column by computing it from other columns. "

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 84,

   "metadata": {},

   "outputs": [],

   "source": [

    "plco.loc[:, 'bmi'] = plco['weight_f'] / plco['height_f']**2 * 703\n",

    "nlst['bmi'] = nlst['weight_f'] / nlst['height_f']**2 * 703"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "Finally, we extract the feature columns and the output column for both the training and testing sets."

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 85,

   "metadata": {},

   "outputs": [],

   "source": [

    "x_plco = plco.drop(columns= ['lung_cancer'])\n",

    "y_plco = plco['lung_cancer']\n",

    "x_nlst = nlst.drop(columns=['lung_cancer'])\n",

    "y_nlst = nlst['lung_cancer']"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {

    "id": "tdVqaDadXROT"

   },

   "source": [

    "# MODEL \n",

    "\n",

    "To build a machine learning model able to predict the risk of lung cancer, we train an XGBoost on the pre-processed PLCO dataset. \n",

    "We then test the model on an external dataset: the NLST dataset.\n",

    "\n",

    "Column to predict : lung_cancer\n",

    "\n",

    "**Optimization**\n",

    "\n",

    "Instead of doing a Grid Search to optimize our parameters, we will use a Package from scikit-learn named skopt. \n",

    "\n",

    "**Calibration**\n",

    "\n",

    "To see if our models are calibrated, we will use a CVcalibration from the scikit learn package.\n",

    "\n",

    "**Interpretability**\n",

    "\n",

    "After doing all of this, we will try to interpret our model by looking at the Shapley Values. These will give us an idea of which features are the most important ones. \n"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 86,

   "metadata": {},

   "outputs": [],

   "source": [

    "x_train, x_val, y_train, y_val = train_test_split(x_plco, y_plco, test_size=0.3)\n",

    "x_test,y_test = x_nlst, y_nlst"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 87,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "---------- VALIDATION DATASET ------------\n",

      "              precision    recall  f1-score   support\n",

      "\n",

      "           0       0.95      0.99      0.97     15749\n",

      "           1       0.40      0.07      0.12       800\n",

      "\n",

      "    accuracy                           0.95     16549\n",

      "   macro avg       0.68      0.53      0.55     16549\n",

      "weighted avg       0.93      0.95      0.93     16549\n",

      "\n",

      "ROC AUC score validation 0.790324385675281\n",

      "F_1 score  0.11914893617021277\n",

      "Precision score  0.4\n",

      "Recall score  0.07\n",

      "PR AUC score   0.07295739923862468\n",

      "---------- TESTING DATASET ------------\n",

      "              precision    recall  f1-score   support\n",

      "\n",

      "           0       0.97      0.96      0.97     47084\n",

      "           1       0.08      0.11      0.09      1511\n",

      "\n",

      "    accuracy                           0.93     48595\n",

      "   macro avg       0.52      0.53      0.53     48595\n",

      "weighted avg       0.94      0.93      0.94     48595\n",

      "\n",

      "ROC AUC score validation 0.6582187468321258\n",

      "F_1 score  0.08927568781583378\n",

      "Precision score  0.07752315943442223\n",

      "Recall score  0.10522832561217736\n",

      "PR AUC score   0.03597942462891982\n"

     ]

    }

   ],

   "source": [

    "model_all_features = xgb.XGBClassifier(random_state=0, \n",

    "                        booster='gbtree', \n",

    "                        objective='binary:logistic', \n",

    "                        eval_metric='aucpr',\n",

    "                        tree_method='exact')\n",

    "model_all_features.fit(x_train, y_train)\n",

    "\n",

    "y_val_pred = model_all_features.predict(x_val)\n",

    "y_val_prob_pred = model_all_features.predict_proba(x_val)\n",

    "print(\"---------- VALIDATION DATASET ------------\")\n",

    "print(classification_report(y_val,y_val_pred))\n",

    "print(\"ROC AUC score validation\", roc_auc_score(y_val, y_val_prob_pred[:, 1]))\n",

    "print(\"F_1 score \", f1_score(y_val, y_val_pred))\n",

    "print(\"Precision score \", precision_score(y_val, y_val_pred))\n",

    "print(\"Recall score \", recall_score(y_val, y_val_pred))\n",

    "print(\"PR AUC score  \", average_precision_score(y_val, y_val_pred))\n",

    "\n",

    "y_test_pred = model_all_features.predict(x_test)\n",

    "y_test_prob_pred = model_all_features.predict_proba(x_test)\n",

    "print(\"---------- TESTING DATASET ------------\")\n",

    "print(classification_report(y_test,y_test_pred))\n",

    "print(\"ROC AUC score validation\", roc_auc_score(y_test, y_test_prob_pred[:, 1]))\n",

    "print(\"F_1 score \", f1_score(y_test, y_test_pred))\n",

    "print(\"Precision score \", precision_score(y_test, y_test_pred))\n",

    "print(\"Recall score \", recall_score(y_test, y_test_pred))\n",

    "print(\"PR AUC score  \", average_precision_score(y_test, y_test_pred))\n"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We look at which features are important:"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 88,

   "metadata": {},

   "outputs": [

    {

     "name": "stderr",

     "output_type": "stream",

     "text": [

      "ntree_limit is deprecated, use `iteration_range` or model slicing instead.\n"

     ]

    },

    {

     "data": {

      "image/png": "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",

      "text/plain": [

       "<Figure size 800x950 with 1 Axes>"

      ]

     },

     "metadata": {},

     "output_type": "display_data"

    }

   ],

   "source": [

    "#To see importance over the entire dataset\n",

    "shap_values = shap.Explainer(model_all_features).shap_values(x_train)\n",

    "shap.summary_plot(shap_values, x_train, plot_type=\"bar\")"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We then select the features to extract:"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 89,

   "metadata": {},

   "outputs": [],

   "source": [

    "#Feature selection\n",

    "columns_to_keep = ['age', 'ssmokea_f', 'cig_stat', 'pack_years', 'smokea_f', \n",

    "                  'cig_years', 'lung_fh', 'bmi'] \n",

    "x_plco = x_plco[columns_to_keep]\n",

    "x_nlst = x_nlst[columns_to_keep]\n",

    "\n",

    "x_train, x_val, y_train, y_val = train_test_split(x_plco, y_plco, test_size=0.3)\n",

    "x_test,y_test = x_nlst, y_nlst"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We now save the pre-processed data for further data analysis for the sake of the writing of the article. "

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 90,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "Pre-processed data sets exported and saved!\n"

     ]

    }

   ],

   "source": [

    "#For PLCO\n",

    "final_plco = x_plco.copy()\n",

    "final_plco['lung_cancer'] = y_plco.copy()\n",

    "final_plco.to_csv('./preprocessed_plco.csv') \n",

    "#For NLST\n",

    "final_nlst = x_nlst.copy()\n",

    "final_nlst['lung_cancer'] = y_nlst.copy()\n",

    "final_nlst.to_csv('./preprocessed_nlst.csv') \n",

    "\n",

    "print(\"Pre-processed data sets exported and saved!\")"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "We now optimize the XGBoost model (commented in this case because already done)"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 91,

   "metadata": {},

   "outputs": [],

   "source": [

    "#######\n",

    "# Uncomment the following to perform hyperparameter optimisation\n",

    "#######\n",

    "\n",

    "# # Setting the basic regressor\n",

    "# reg = xgb.XGBClassifier(random_state=0, \n",

    "#                         booster='gbtree', \n",

    "#                         objective='binary:logistic', \n",

    "#                         eval_metric='aucpr',\n",

    "#                         tree_method='exact')\n",

    "\n",

    "# # Setting the validation strategy\n",

    "# skf = StratifiedKFold(n_splits=7,\n",

    "#                       shuffle=True, \n",

    "#                       random_state=0)\n",

    "\n",

    "# cv_strategy = list(skf.split(x_train, y_train))\n",

    "\n",

    "# search_spaces = {'learning_rate': Real(0.01, 1.0, 'uniform'),\n",

    "#                  'max_depth': Integer(2, 10),\n",

    "#                  'subsample': Real(0.1, 1.0, 'uniform'),\n",

    "#                  'colsample_bytree': Real(0.1, 1.0, 'uniform'),\n",

    "#                  'n_estimators': Integer(50, 1000),\n",

    "#                  'reg_alpha': Real(0.001, 100., 'uniform'), \n",

    "#    }\n",

    "\n",

    "\n",

    "# opt = BayesSearchCV(estimator=reg,                                    \n",

    "#                     search_spaces=search_spaces,                                 \n",

    "#                     cv=cv_strategy,                                           \n",

    "#                     n_iter=300,                                       # max number of trials\n",

    "#                     n_points=1,                                       # number of hyperparameter sets evaluated at the same time\n",

    "#                     n_jobs=1,                                         # number of jobs\n",

    "#                     iid=False,                                        # if not iid it optimizes on the cv score\n",

    "#                     return_train_score=False,                         \n",

    "#                     refit=False,                                      \n",

    "#                     optimizer_kwargs={'base_estimator': 'GP'},        # optmizer parameters: we use Gaussian Process (GP)\n",

    "#                     random_state=0)                                   # random state for replicability\n",

    "\n",

    "# # Running the optimizer\n",

    "# overdone_control = DeltaYStopper(delta=0.0001)                    # We stop if the gain of the optimization becomes too small\n",

    "# time_limit_control = DeadlineStopper(total_time=60*60*3)          # We impose a time limit (5 hours)\n",

    "\n",

    "# best_params = report_perf(opt, x_train, y_train,'XGBoost_regression', \n",

    "#                           callbacks=[overdone_control, time_limit_control])\n",

    "\n",

    "\n",

    "\n",

    "#######\n",

    "# Comment the following to perform hyperparameter optimisation (this is the result of our optimisation)\n",

    "#######\n",

    "\n",

    "best_params = {'colsample_bytree': 0.3092626254072385,\n",

    "             'learning_rate': 0.25090257611371497,\n",

    "             'max_depth': 8,\n",

    "             'n_estimators': 321,\n",

    "             'reg_alpha': 18.11046009958031,\n",

    "             'subsample': 0.3282432744048327\n",

    "}"

   ]

  },

  {

   "attachments": {},

   "cell_type": "markdown",

   "metadata": {},

   "source": [

    "Now we train the model on the reduced list of features:"

   ]

  },

  {

   "cell_type": "code",

   "execution_count": 92,

   "metadata": {},

   "outputs": [

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "[0]\tvalidation_0-aucpr:0.05140\tvalidation_1-aucpr:0.05248\n",

      "[1]\tvalidation_0-aucpr:0.11519\tvalidation_1-aucpr:0.11218\n",

      "[2]\tvalidation_0-aucpr:0.17062\tvalidation_1-aucpr:0.16237\n"

     ]

    },

    {

     "name": "stdout",

     "output_type": "stream",

     "text": [

      "[3]\tvalidation_0-aucpr:0.18303\tvalidation_1-aucpr:0.17115\n",

      "[4]\tvalidation_0-aucpr:0.19606\tvalidation_1-aucpr:0.18545\n",

      "[5]\tvalidation_0-aucpr:0.19793\tvalidation_1-aucpr:0.18583\n",

      "[6]\tvalidation_0-aucpr:0.20432\tvalidation_1-aucpr:0.19319\n",

      "[7]\tvalidation_0-aucpr:0.20480\tvalidation_1-aucpr:0.19465\n",

      "[8]\tvalidation_0-aucpr:0.21262\tvalidation_1-aucpr:0.19805\n",

      "[9]\tvalidation_0-aucpr:0.21399\tvalidation_1-aucpr:0.19905\n",

      "[10]\tvalidation_0-aucpr:0.21977\tvalidation_1-aucpr:0.20373\n",

      "[11]\tvalidation_0-aucpr:0.22132\tvalidation_1-aucpr:0.20826\n",

      "[12]\tvalidation_0-aucpr:0.22260\tvalidation_1-aucpr:0.21062\n",

      "[13]\tvalidation_0-aucpr:0.22339\tvalidation_1-aucpr:0.21096\n",

      "[14]\tvalidation_0-aucpr:0.22471\tvalidation_1-aucpr:0.21515\n",

      "[15]\tvalidation_0-aucpr:0.22504\tvalidation_1-aucpr:0.21424\n",

      "[16]\tvalidation_0-aucpr:0.22510\tvalidation_1-aucpr:0.21369\n",

      "[17]\tvalidation_0-aucpr:0.22523\tvalidation_1-aucpr:0.21345\n",

      "[18]\tvalidation_0-aucpr:0.22574\tvalidation_1-aucpr:0.21162\n",

      "[19]\tvalidation_0-aucpr:0.22569\tvalidation_1-aucpr:0.21105\n",

      "[20]\tvalidation_0-aucpr:0.22643\tvalidation_1-aucpr:0.21243\n",

      "[21]\tvalidation_0-aucpr:0.22619\tvalidation_1-aucpr:0.21166\n",

      "[22]\tvalidation_0-aucpr:0.22650\tvalidation_1-aucpr:0.21413\n",

      "[23]\tvalidation_0-aucpr:0.22737\tvalidation_1-aucpr:0.21466\n",

      "[24]\tvalidation_0-aucpr:0.22863\tvalidation_1-aucpr:0.21444\n",

      "[25]\tvalidation_0-aucpr:0.23048\tvalidation_1-aucpr:0.21396\n",

      "[26]\tvalidation_0-aucpr:0.23092\tvalidation_1-aucpr:0.21430\n",

      "[27]\tvalidation_0-aucpr:0.23081\tvalidation_1-aucpr:0.21416\n",

      "[28]\tvalidation_0-aucpr:0.23163\tvalidation_1-aucpr:0.21426\n",

      "[29]\tvalidation_0-aucpr:0.23157\tvalidation_1-aucpr:0.21413\n",

      "[30]\tvalidation_0-aucpr:0.23146\tvalidation_1-aucpr:0.21408\n",

      "[31]\tvalidation_0-aucpr:0.23183\tvalidation_1-aucpr:0.21374\n",

      "[32]\tvalidation_0-aucpr:0.23183\tvalidation_1-aucpr:0.21374\n",

      "[33]\tvalidation_0-aucpr:0.23231\tvalidation_1-aucpr:0.21401\n",

      "[34]\tvalidation_0-aucpr:0.23279\tvalidation_1-aucpr:0.21421\n",

      "[35]\tvalidation_0-aucpr:0.23308\tvalidation_1-aucpr:0.21400\n",

      "[36]\tvalidation_0-aucpr:0.23325\tvalidation_1-aucpr:0.21458\n",

      "[37]\tvalidation_0-aucpr:0.23357\tvalidation_1-aucpr:0.21502\n",

      "[38]\tvalidation_0-aucpr:0.23364\tvalidation_1-aucpr:0.21502\n",

      "[39]\tvalidation_0-aucpr:0.23373\tvalidation_1-aucpr:0.21489\n",

      "[40]\tvalidation_0-aucpr:0.23547\tvalidation_1-aucpr:0.21556\n",

      "[41]\tvalidation_0-aucpr:0.23622\tvalidation_1-aucpr:0.21606\n",

      "[42]\tvalidation_0-aucpr:0.23639\tvalidation_1-aucpr:0.21730\n",

      "[43]\tvalidation_0-aucpr:0.23643\tvalidation_1-aucpr:0.21735\n",

      "[44]\tvalidation_0-aucpr:0.23643\tvalidation_1-aucpr:0.21736\n",

      "[45]\tvalidation_0-aucpr:0.23658\tvalidation_1-aucpr:0.21752\n",

      "[46]\tvalidation_0-aucpr:0.23758\tvalidation_1-aucpr:0.21846\n",

      "[47]\tvalidation_0-aucpr:0.23769\tvalidation_1-aucpr:0.21845\n",

      "[48]\tvalidation_0-aucpr:0.23772\tvalidation_1-aucpr:0.21852\n",

      "[49]\tvalidation_0-aucpr:0.23833\tvalidation_1-aucpr:0.21946\n",

      "[50]\tvalidation_0-aucpr:0.23850\tvalidation_1-aucpr:0.21892\n",

      "[51]\tvalidation_0-aucpr:0.23853\tvalidation_1-aucpr:0.21867\n",

      "[52]\tvalidation_0-aucpr:0.23842\tvalidation_1-aucpr:0.21847\n",

      "[53]\tvalidation_0-aucpr:0.23859\tvalidation_1-aucpr:0.21871\n",

      "[54]\tvalidation_0-aucpr:0.23887\tvalidation_1-aucpr:0.21953\n",

      "[55]\tvalidation_0-aucpr:0.23909\tvalidation_1-aucpr:0.22025\n",

      "[56]\tvalidation_0-aucpr:0.23926\tvalidation_1-aucpr:0.22021\n",

      "[57]\tvalidation_0-aucpr:0.23932\tvalidation_1-aucpr:0.22054\n",

      "[58]\tvalidation_0-aucpr:0.23904\tvalidation_1-aucpr:0.22076\n",

      "[59]\tvalidation_0-aucpr:0.23911\tvalidation_1-aucpr:0.22058\n",

      "[60]\tvalidation_0-aucpr:0.23911\tvalidation_1-aucpr:0.22059\n",

      "[61]\tvalidation_0-aucpr:0.23959\tvalidation_1-aucpr:0.22110\n",

      "[62]\tvalidation_0-aucpr:0.23982\tvalidation_1-aucpr:0.22098\n",

      "[63]\tvalidation_0-aucpr:0.23973\tvalidation_1-aucpr:0.22092\n",

      "[64]\tvalidation_0-aucpr:0.23997\tvalidation_1-aucpr:0.22097\n",

      "[65]\tvalidation_0-aucpr:0.24004\tvalidation_1-aucpr:0.22111\n",

      "[66]\tvalidation_0-aucpr:0.24027\tvalidation_1-aucpr:0.22214\n",

      "[67]\tvalidation_0-aucpr:0.24050\tvalidation_1-aucpr:0.22271\n",

      "[68]\tvalidation_0-aucpr:0.24061\tvalidation_1-aucpr:0.22218\n",

      "[69]\tvalidation_0-aucpr:0.24083\tvalidation_1-aucpr:0.22224\n",

      "[70]\tvalidation_0-aucpr:0.24091\tvalidation_1-aucpr:0.22203\n",

      "[71]\tvalidation_0-aucpr:0.24152\tvalidation_1-aucpr:0.22183\n",

      "[72]\tvalidation_0-aucpr:0.24175\tvalidation_1-aucpr:0.22197\n",

      "[73]\tvalidation_0-aucpr:0.24221\tvalidation_1-aucpr:0.22259\n",

      "[74]\tvalidation_0-aucpr:0.24223\tvalidation_1-aucpr:0.22261\n",

      "[75]\tvalidation_0-aucpr:0.24235\tvalidation_1-aucpr:0.22201\n",

      "[76]\tvalidation_0-aucpr:0.24251\tvalidation_1-aucpr:0.22253\n",

      "[77]\tvalidation_0-aucpr:0.24267\tvalidation_1-aucpr:0.22257\n",

      "[78]\tvalidation_0-aucpr:0.24267\tvalidation_1-aucpr:0.22257\n",

      "[79]\tvalidation_0-aucpr:0.24295\tvalidation_1-aucpr:0.22247\n",

      "[80]\tvalidation_0-aucpr:0.24294\tvalidation_1-aucpr:0.22164\n",

      "[81]\tvalidation_0-aucpr:0.24297\tvalidation_1-aucpr:0.22139\n",

      "[82]\tvalidation_0-aucpr:0.24304\tvalidation_1-aucpr:0.22132\n",

      "[83]\tvalidation_0-aucpr:0.24306\tvalidation_1-aucpr:0.22140\n",

      "[84]\tvalidation_0-aucpr:0.24311\tvalidation_1-aucpr:0.22173\n",

      "[85]\tvalidation_0-aucpr:0.24309\tvalidation_1-aucpr:0.22167\n",

      "[86]\tvalidation_0-aucpr:0.24305\tvalidation_1-aucpr:0.22178\n",

      "[87]\tvalidation_0-aucpr:0.24332\tvalidation_1-aucpr:0.22302\n",

      "[88]\tvalidation_0-aucpr:0.24339\tvalidation_1-aucpr:0.22293\n",

      "[89]\tvalidation_0-aucpr:0.24357\tvalidation_1-aucpr:0.22292\n",

      "[90]\tvalidation_0-aucpr:0.24357\tvalidation_1-aucpr:0.22293\n",

      "[91]\tvalidation_0-aucpr:0.24350\tvalidation_1-aucpr:0.22251\n",

      "[92]\tvalidation_0-aucpr:0.24371\tvalidation_1-aucpr:0.22252\n",

      "[93]\tvalidation_0-aucpr:0.24342\tvalidation_1-aucpr:0.22314\n",

      "[94]\tvalidation_0-aucpr:0.24339\tvalidation_1-aucpr:0.22289\n",

      "[95]\tvalidation_0-aucpr:0.24343\tvalidation_1-aucpr:0.22290\n",

      "[96]\tvalidation_0-aucpr:0.24347\tvalidation_1-aucpr:0.22257\n",

      "[97]\tvalidation_0-aucpr:0.24358\tvalidation_1-aucpr:0.22281\n",

      "[98]\tvalidation_0-aucpr:0.24343\tvalidation_1-aucpr:0.22301\n",

      "[99]\tvalidation_0-aucpr:0.24343\tvalidation_1-aucpr:0.22301\n",

      "[100]\tvalidation_0-aucpr:0.24340\tvalidation_1-aucpr:0.22301\n",

      "[101]\tvalidation_0-aucpr:0.24344\tvalidation_1-aucpr:0.22312\n",

      "[102]\tvalidation_0-aucpr:0.24356\tvalidation_1-aucpr:0.22287\n",

      "[103]\tvalidation_0-aucpr:0.24361\tvalidation_1-aucpr:0.22226\n",

      "[104]\tvalidation_0-aucpr:0.24365\tvalidation_1-aucpr:0.22257\n",

      "[105]\tvalidation_0-aucpr:0.24380\tvalidation_1-aucpr:0.22326\n",

      "[106]\tvalidation_0-aucpr:0.24404\tvalidation_1-aucpr:0.22257\n",

      "[107]\tvalidation_0-aucpr:0.24405\tvalidation_1-aucpr:0.22272\n",

      "[108]\tvalidation_0-aucpr:0.24405\tvalidation_1-aucpr:0.22272\n",

      "[109]\tvalidation_0-aucpr:0.24413\tvalidation_1-aucpr:0.22260\n",

      "[110]\tvalidation_0-aucpr:0.24434\tvalidation_1-aucpr:0.22240\n",

      "[111]\tvalidation_0-aucpr:0.24445\tvalidation_1-aucpr:0.22216\n",

      "[112]\tvalidation_0-aucpr:0.24445\tvalidation_1-aucpr:0.22216\n",

      "[113]\tvalidation_0-aucpr:0.24484\tvalidation_1-aucpr:0.22251\n",

      "[114]\tvalidation_0-aucpr:0.24494\tvalidation_1-aucpr:0.22259\n",

      "[115]\tvalidation_0-aucpr:0.24487\tvalidation_1-aucpr:0.22249\n",

      "[116]\tvalidation_0-aucpr:0.24511\tvalidation_1-aucpr:0.22332\n",

      "[117]\tvalidation_0-aucpr:0.24523\tvalidation_1-aucpr:0.22292\n",

      "[118]\tvalidation_0-aucpr:0.24513\tvalidation_1-aucpr:0.22336\n",

      "[119]\tvalidation_0-aucpr:0.24519\tvalidation_1-aucpr:0.22323\n",

      "[120]\tvalidation_0-aucpr:0.24528\tvalidation_1-aucpr:0.22326\n",

      "[121]\tvalidation_0-aucpr:0.24528\tvalidation_1-aucpr:0.22326\n",

      "[122]\tvalidation_0-aucpr:0.24536\tvalidation_1-aucpr:0.22333\n",

      "[123]\tvalidation_0-aucpr:0.24579\tvalidation_1-aucpr:0.22389\n",

      "[124]\tvalidation_0-aucpr:0.24579\tvalidation_1-aucpr:0.22392\n",

      "[125]\tvalidation_0-aucpr:0.24577\tvalidation_1-aucpr:0.22388\n",

      "[126]\tvalidation_0-aucpr:0.24578\tvalidation_1-aucpr:0.22386\n",

      "[127]\tvalidation_0-aucpr:0.24587\tvalidation_1-aucpr:0.22379\n",

      "[128]\tvalidation_0-aucpr:0.24588\tvalidation_1-aucpr:0.22343\n",

      "[129]\tvalidation_0-aucpr:0.24588\tvalidation_1-aucpr:0.22343\n",

      "[130]\tvalidation_0-aucpr:0.24593\tvalidation_1-aucpr:0.22339\n",

      "[131]\tvalidation_0-aucpr:0.24636\tvalidation_1-aucpr:0.22376\n",

      "[132]\tvalidation_0-aucpr:0.24639\tvalidation_1-aucpr:0.22347\n",

      "[133]\tvalidation_0-aucpr:0.24638\tvalidation_1-aucpr:0.22330\n",

      "[134]\tvalidation_0-aucpr:0.24644\tvalidation_1-aucpr:0.22332\n",

      "[135]\tvalidation_0-aucpr:0.24658\tvalidation_1-aucpr:0.22368\n",

      "[136]\tvalidation_0-aucpr:0.24662\tvalidation_1-aucpr:0.22368\n",

      "[137]\tvalidation_0-aucpr:0.24664\tvalidation_1-aucpr:0.22365\n",

      "[138]\tvalidation_0-aucpr:0.24633\tvalidation_1-aucpr:0.22429\n",

      "[139]\tvalidation_0-aucpr:0.24636\tvalidation_1-aucpr:0.22423\n",

      "[140]\tvalidation_0-aucpr:0.24640\tvalidation_1-aucpr:0.22434\n",

      "[141]\tvalidation_0-aucpr:0.24644\tvalidation_1-aucpr:0.22395\n",

      "[142]\tvalidation_0-aucpr:0.24637\tvalidation_1-aucpr:0.22430\n",

      "[143]\tvalidation_0-aucpr:0.24637\tvalidation_1-aucpr:0.22430\n",

      "[144]\tvalidation_0-aucpr:0.24649\tvalidation_1-aucpr:0.22452\n",

      "[145]\tvalidation_0-aucpr:0.24652\tvalidation_1-aucpr:0.22433\n",

      "[146]\tvalidation_0-aucpr:0.24659\tvalidation_1-aucpr:0.22414\n",

      "[147]\tvalidation_0-aucpr:0.24695\tvalidation_1-aucpr:0.22398\n",

      "[148]\tvalidation_0-aucpr:0.24694\tvalidation_1-aucpr:0.22401\n",

      "[149]\tvalidation_0-aucpr:0.24694\tvalidation_1-aucpr:0.22402\n",

      "[150]\tvalidation_0-aucpr:0.24714\tvalidation_1-aucpr:0.22381\n",

      "[151]\tvalidation_0-aucpr:0.24713\tvalidation_1-aucpr:0.22429\n",

      "[152]\tvalidation_0-aucpr:0.24719\tvalidation_1-aucpr:0.22429\n",

      "[153]\tvalidation_0-aucpr:0.24719\tvalidation_1-aucpr:0.22429\n",

      "[154]\tvalidation_0-aucpr:0.24719\tvalidation_1-aucpr:0.22431\n",

      "[155]\tvalidation_0-aucpr:0.24695\tvalidation_1-aucpr:0.22470\n",

      "[156]\tvalidation_0-aucpr:0.24695\tvalidation_1-aucpr:0.22470\n",

      "[157]\tvalidation_0-aucpr:0.24695\tvalidation_1-aucpr:0.22468\n",

      "[158]\tvalidation_0-aucpr:0.24700\tvalidation_1-aucpr:0.22499\n",

      "[159]\tvalidation_0-aucpr:0.24735\tvalidation_1-aucpr:0.22472\n",

      "[160]\tvalidation_0-aucpr:0.24748\tvalidation_1-aucpr:0.22502\n",

      "[161]\tvalidation_0-aucpr:0.24748\tvalidation_1-aucpr:0.22502\n",

      "[162]\tvalidation_0-aucpr:0.24749\tvalidation_1-aucpr:0.22479\n",

      "[163]\tvalidation_0-aucpr:0.24720\tvalidation_1-aucpr:0.22384\n",

      "[164]\tvalidation_0-aucpr:0.24733\tvalidation_1-aucpr:0.22380\n",

      "[165]\tvalidation_0-aucpr:0.24721\tvalidation_1-aucpr:0.22363\n",

      "[166]\tvalidation_0-aucpr:0.24725\tvalidation_1-aucpr:0.22364\n",

      "[167]\tvalidation_0-aucpr:0.24723\tvalidation_1-aucpr:0.22375\n",

      "[168]\tvalidation_0-aucpr:0.24818\tvalidation_1-aucpr:0.22439\n",

      "[169]\tvalidation_0-aucpr:0.24824\tvalidation_1-aucpr:0.22428\n",

      "[170]\tvalidation_0-aucpr:0.24830\tvalidation_1-aucpr:0.22448\n",

      "[171]\tvalidation_0-aucpr:0.24829\tvalidation_1-aucpr:0.22469\n",

      "[172]\tvalidation_0-aucpr:0.24848\tvalidation_1-aucpr:0.22364\n",

      "[173]\tvalidation_0-aucpr:0.24855\tvalidation_1-aucpr:0.22356\n",

      "[174]\tvalidation_0-aucpr:0.24844\tvalidation_1-aucpr:0.22373\n",

      "[175]\tvalidation_0-aucpr:0.24852\tvalidation_1-aucpr:0.22378\n",

      "[176]\tvalidation_0-aucpr:0.24852\tvalidation_1-aucpr:0.22378\n",

      "[177]\tvalidation_0-aucpr:0.24864\tvalidation_1-aucpr:0.22405\n",

      "[178]\tvalidation_0-aucpr:0.24859\tvalidation_1-aucpr:0.22461\n",

      "[179]\tvalidation_0-aucpr:0.24859\tvalidation_1-aucpr:0.22461\n",

      "[180]\tvalidation_0-aucpr:0.24859\tvalidation_1-aucpr:0.22424\n",

      "[181]\tvalidation_0-aucpr:0.24862\tvalidation_1-aucpr:0.22423\n",

      "[182]\tvalidation_0-aucpr:0.24864\tvalidation_1-aucpr:0.22413\n",

      "[183]\tvalidation_0-aucpr:0.24864\tvalidation_1-aucpr:0.22413\n",

      "[184]\tvalidation_0-aucpr:0.24861\tvalidation_1-aucpr:0.22437\n",

      "[185]\tvalidation_0-aucpr:0.24873\tvalidation_1-aucpr:0.22438\n",

      "[186]\tvalidation_0-aucpr:0.24871\tvalidation_1-aucpr:0.22439\n",

      "[187]\tvalidation_0-aucpr:0.24889\tvalidation_1-aucpr:0.22487\n",

      "[188]\tvalidation_0-aucpr:0.24892\tvalidation_1-aucpr:0.22499\n",

      "[189]\tvalidation_0-aucpr:0.24908\tvalidation_1-aucpr:0.22529\n",

      "[190]\tvalidation_0-aucpr:0.24908\tvalidation_1-aucpr:0.22546\n",

      "[191]\tvalidation_0-aucpr:0.24908\tvalidation_1-aucpr:0.22546\n",

      "[192]\tvalidation_0-aucpr:0.24924\tvalidation_1-aucpr:0.22550\n",

      "[193]\tvalidation_0-aucpr:0.24925\tvalidation_1-aucpr:0.22541\n",

      "[194]\tvalidation_0-aucpr:0.24925\tvalidation_1-aucpr:0.22541\n",

      "[195]\tvalidation_0-aucpr:0.24930\tvalidation_1-aucpr:0.22562\n",

      "[196]\tvalidation_0-aucpr:0.24943\tvalidation_1-aucpr:0.22666\n",

      "[197]\tvalidation_0-aucpr:0.24932\tvalidation_1-aucpr:0.22664\n",

      "[198]\tvalidation_0-aucpr:0.24955\tvalidation_1-aucpr:0.22612\n",

      "[199]\tvalidation_0-aucpr:0.24981\tvalidation_1-aucpr:0.22624\n",

      "[200]\tvalidation_0-aucpr:0.24981\tvalidation_1-aucpr:0.22624\n",

      "[201]\tvalidation_0-aucpr:0.24981\tvalidation_1-aucpr:0.22624\n",

      "[202]\tvalidation_0-aucpr:0.24983\tvalidation_1-aucpr:0.22606\n",

      "[203]\tvalidation_0-aucpr:0.24995\tvalidation_1-aucpr:0.22589\n",

      "[204]\tvalidation_0-aucpr:0.25006\tvalidation_1-aucpr:0.22555\n",

      "[205]\tvalidation_0-aucpr:0.25016\tvalidation_1-aucpr:0.22524\n",

      "[206]\tvalidation_0-aucpr:0.25018\tvalidation_1-aucpr:0.22498\n",

      "[207]\tvalidation_0-aucpr:0.25020\tvalidation_1-aucpr:0.22490\n",

      "[208]\tvalidation_0-aucpr:0.25011\tvalidation_1-aucpr:0.22492\n",

      "[209]\tvalidation_0-aucpr:0.25020\tvalidation_1-aucpr:0.22490\n",

      "[210]\tvalidation_0-aucpr:0.25018\tvalidation_1-aucpr:0.22489\n",

      "[211]\tvalidation_0-aucpr:0.24998\tvalidation_1-aucpr:0.22551\n",

      "[212]\tvalidation_0-aucpr:0.25000\tvalidation_1-aucpr:0.22552\n",

      "[213]\tvalidation_0-aucpr:0.24980\tvalidation_1-aucpr:0.22552\n",

      "[214]\tvalidation_0-aucpr:0.24996\tvalidation_1-aucpr:0.22530\n",

      "[215]\tvalidation_0-aucpr:0.24996\tvalidation_1-aucpr:0.22530\n",

      "[216]\tvalidation_0-aucpr:0.25061\tvalidation_1-aucpr:0.22504\n",

      "[217]\tvalidation_0-aucpr:0.25075\tvalidation_1-aucpr:0.22548\n",

      "[218]\tvalidation_0-aucpr:0.25075\tvalidation_1-aucpr:0.22548\n",

      "[219]\tvalidation_0-aucpr:0.25073\tvalidation_1-aucpr:0.22524\n",

      "[220]\tvalidation_0-aucpr:0.25078\tvalidation_1-aucpr:0.22530\n",

      "[221]\tvalidation_0-aucpr:0.25078\tvalidation_1-aucpr:0.22530\n",

      "[222]\tvalidation_0-aucpr:0.25083\tvalidation_1-aucpr:0.22536\n",

      "[223]\tvalidation_0-aucpr:0.25078\tvalidation_1-aucpr:0.22566\n",

      "[224]\tvalidation_0-aucpr:0.25079\tvalidation_1-aucpr:0.22551\n",

      "[225]\tvalidation_0-aucpr:0.25076\tvalidation_1-aucpr:0.22562\n",

      "[226]\tvalidation_0-aucpr:0.25099\tvalidation_1-aucpr:0.22562\n",

      "[227]\tvalidation_0-aucpr:0.25103\tvalidation_1-aucpr:0.22581\n",

      "[228]\tvalidation_0-aucpr:0.25113\tvalidation_1-aucpr:0.22556\n",

      "[229]\tvalidation_0-aucpr:0.25126\tvalidation_1-aucpr:0.22542\n",

      "[230]\tvalidation_0-aucpr:0.25126\tvalidation_1-aucpr:0.22542\n",

      "[231]\tvalidation_0-aucpr:0.25135\tvalidation_1-aucpr:0.22521\n",

      "[232]\tvalidation_0-aucpr:0.25135\tvalidation_1-aucpr:0.22521\n",

      "[233]\tvalidation_0-aucpr:0.25139\tvalidation_1-aucpr:0.22526\n",

      "[234]\tvalidation_0-aucpr:0.25139\tvalidation_1-aucpr:0.22539\n",

      "[235]\tvalidation_0-aucpr:0.25133\tvalidation_1-aucpr:0.22525\n",

      "[236]\tvalidation_0-aucpr:0.25133\tvalidation_1-aucpr:0.22525\n",

      "[237]\tvalidation_0-aucpr:0.25167\tvalidation_1-aucpr:0.22550\n",

      "[238]\tvalidation_0-aucpr:0.25194\tvalidation_1-aucpr:0.22525\n",

      "[239]\tvalidation_0-aucpr:0.25206\tvalidation_1-aucpr:0.22495\n",

      "[240]\tvalidation_0-aucpr:0.25203\tvalidation_1-aucpr:0.22505\n",

      "[241]\tvalidation_0-aucpr:0.25203\tvalidation_1-aucpr:0.22505\n",

      "[242]\tvalidation_0-aucpr:0.25215\tvalidation_1-aucpr:0.22489\n",

      "[243]\tvalidation_0-aucpr:0.25237\tvalidation_1-aucpr:0.22412\n",

      "[244]\tvalidation_0-aucpr:0.25243\tvalidation_1-aucpr:0.22412\n",

      "[245]\tvalidation_0-aucpr:0.25248\tvalidation_1-aucpr:0.22415\n",

      "[246]\tvalidation_0-aucpr:0.25248\tvalidation_1-aucpr:0.22415\n",

      "[247]\tvalidation_0-aucpr:0.25248\tvalidation_1-aucpr:0.22415\n",

      "[248]\tvalidation_0-aucpr:0.25249\tvalidation_1-aucpr:0.22414\n",

      "[249]\tvalidation_0-aucpr:0.25263\tvalidation_1-aucpr:0.22440\n",

      "[250]\tvalidation_0-aucpr:0.25253\tvalidation_1-aucpr:0.22428\n",

      "[251]\tvalidation_0-aucpr:0.25264\tvalidation_1-aucpr:0.22445\n",

      "[252]\tvalidation_0-aucpr:0.25264\tvalidation_1-aucpr:0.22445\n",

      "[253]\tvalidation_0-aucpr:0.25269\tvalidation_1-aucpr:0.22435\n",

      "[254]\tvalidation_0-aucpr:0.25269\tvalidation_1-aucpr:0.22435\n",

      "[255]\tvalidation_0-aucpr:0.25276\tvalidation_1-aucpr:0.22381\n",

      "[256]\tvalidation_0-aucpr:0.25275\tvalidation_1-aucpr:0.22356\n",

      "[257]\tvalidation_0-aucpr:0.25278\tvalidation_1-aucpr:0.22353\n",

      "[258]\tvalidation_0-aucpr:0.25278\tvalidation_1-aucpr:0.22353\n",

      "[259]\tvalidation_0-aucpr:0.25283\tvalidation_1-aucpr:0.22351\n",

      "[260]\tvalidation_0-aucpr:0.25298\tvalidation_1-aucpr:0.22355\n",

      "[261]\tvalidation_0-aucpr:0.25298\tvalidation_1-aucpr:0.22355\n",

      "[262]\tvalidation_0-aucpr:0.25292\tvalidation_1-aucpr:0.22331\n",

      "[263]\tvalidation_0-aucpr:0.25313\tvalidation_1-aucpr:0.22353\n",

      "[264]\tvalidation_0-aucpr:0.25328\tvalidation_1-aucpr:0.22351\n",

      "[265]\tvalidation_0-aucpr:0.25322\tvalidation_1-aucpr:0.22375\n",

      "[266]\tvalidation_0-aucpr:0.25382\tvalidation_1-aucpr:0.22358\n",

      "[267]\tvalidation_0-aucpr:0.25382\tvalidation_1-aucpr:0.22358\n",

      "[268]\tvalidation_0-aucpr:0.25360\tvalidation_1-aucpr:0.22382\n",

      "[269]\tvalidation_0-aucpr:0.25373\tvalidation_1-aucpr:0.22375\n",

      "[270]\tvalidation_0-aucpr:0.25367\tvalidation_1-aucpr:0.22392\n",

      "[271]\tvalidation_0-aucpr:0.25363\tvalidation_1-aucpr:0.22385\n",

      "[272]\tvalidation_0-aucpr:0.25364\tvalidation_1-aucpr:0.22369\n",

      "[273]\tvalidation_0-aucpr:0.25353\tvalidation_1-aucpr:0.22358\n",

      "[274]\tvalidation_0-aucpr:0.25367\tvalidation_1-aucpr:0.22349\n",

      "[275]\tvalidation_0-aucpr:0.25387\tvalidation_1-aucpr:0.22356\n",

      "[276]\tvalidation_0-aucpr:0.25377\tvalidation_1-aucpr:0.22306\n",

      "[277]\tvalidation_0-aucpr:0.25377\tvalidation_1-aucpr:0.22306\n",

      "[278]\tvalidation_0-aucpr:0.25377\tvalidation_1-aucpr:0.22306\n",

      "[279]\tvalidation_0-aucpr:0.25380\tvalidation_1-aucpr:0.22320\n",

      "[280]\tvalidation_0-aucpr:0.25384\tvalidation_1-aucpr:0.22327\n",

      "[281]\tvalidation_0-aucpr:0.25388\tvalidation_1-aucpr:0.22309\n",

      "[282]\tvalidation_0-aucpr:0.25388\tvalidation_1-aucpr:0.22307\n",

      "[283]\tvalidation_0-aucpr:0.25376\tvalidation_1-aucpr:0.22320\n",

      "[284]\tvalidation_0-aucpr:0.25376\tvalidation_1-aucpr:0.22320\n",

      "[285]\tvalidation_0-aucpr:0.25379\tvalidation_1-aucpr:0.22318\n",

      "[286]\tvalidation_0-aucpr:0.25406\tvalidation_1-aucpr:0.22309\n",

      "[287]\tvalidation_0-aucpr:0.25423\tvalidation_1-aucpr:0.22295\n",

      "[288]\tvalidation_0-aucpr:0.25424\tvalidation_1-aucpr:0.22293\n",

      "[289]\tvalidation_0-aucpr:0.25426\tvalidation_1-aucpr:0.22306\n",

      "[290]\tvalidation_0-aucpr:0.25426\tvalidation_1-aucpr:0.22306\n",

      "[291]\tvalidation_0-aucpr:0.25426\tvalidation_1-aucpr:0.22306\n",

      "[292]\tvalidation_0-aucpr:0.25427\tvalidation_1-aucpr:0.22332\n",

      "[293]\tvalidation_0-aucpr:0.25440\tvalidation_1-aucpr:0.22353\n",

      "[294]\tvalidation_0-aucpr:0.25440\tvalidation_1-aucpr:0.22353\n",