notebooks/6_LightGBM_predict_multipleDays_for20180918.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26348f96",
   "metadata": {},
   "source": [
    "## Predict the skipping behavior of the validation dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f0e66449",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tarfile\n",
    "import io\n",
    "import glob\n",
    "import dask.dataframe as dd\n",
    "\n",
    "\n",
    "import lightgbm as lgb\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "import myFunc as mf\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "\n",
    "tar = tarfile.open('../data/raw/20181120_track_features.tar.gz', 'r:gz')\n",
    "csv_files = tar.getnames()\n",
    "\n",
    "tf_df_list = []\n",
    "\n",
    "for csv_file in [csv_files[2], csv_files[4]]:\n",
    "    csv_contents = tar.extractfile(csv_file).read()\n",
    "    tf_df_list.append(pd.read_csv(io.BytesIO(csv_contents), encoding='utf8'))\n",
    "\n",
    "tf_df = pd.concat(tf_df_list, ignore_index=True)\n",
    "tf_df.rename(columns={'track_id':'track_id_clean'}, inplace=True)\n",
    "\n",
    "kmean300_df = pd.read_csv('../data/interim/all_data/mbKMeans300clusters.csv', usecols=['track_id','clus'])\n",
    "kmean300_df.rename(columns={'track_id':'track_id_clean'}, inplace=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d573dece",
   "metadata": {},
   "outputs": [],
   "source": [
    "# validation data\n",
    "file_list = ['../data/raw/training_set/log_0_20180918_000000000000.csv']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cf7358b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the same data processing steps but without weights and track selection\n",
    "\n",
    "def prep_dfs_eval(file, tf_df, simFolder, kmean_df):\n",
    "    log_df = pd.read_csv(file)\n",
    "    log_df = log_df.merge(kmean_df)\n",
    "\n",
    "    log_df_1 = log_df.loc[log_df['session_position']<=(log_df['session_length']/2)]\n",
    "    log_df_1['hour_of_day'] = log_df_1['hour_of_day'].astype('float')\n",
    "    log_df_1['premium'] = log_df_1['premium'].astype('bool')\n",
    "    log_df_1 = log_df_1.drop(columns = ['date'])\n",
    "    log_df_1 = pd.get_dummies(log_df_1, columns=['hist_user_behavior_reason_end', 'hist_user_behavior_reason_start', 'context_type'], dtype = 'bool')\n",
    "    log_df_1 = log_df_1.merge(tf_df.drop(columns = ['time_signature','mode','key']))\n",
    "    \n",
    "                     \n",
    "    col_bool = log_df_1.columns[log_df_1.dtypes=='bool']\n",
    "    col_nonbool = log_df_1.columns[log_df_1.dtypes!='bool'].drop(['session_id','track_id_clean','clus'])\n",
    "    \n",
    "    # the non-convertable values will be set to 0\n",
    "    log_df_1[col_nonbool] = log_df_1[col_nonbool].apply(pd.to_numeric, errors='coerce', downcast = 'float').fillna(0).astype('float32')\n",
    "\n",
    "    # aggregate the track history where ['skip_2']==True\n",
    "    log_df_1_summary_skip2True = pd.concat([log_df_1.loc[log_df_1['skip_2']==True].groupby(['session_id'])[col_bool].agg(['mean']), \n",
    "                                            log_df_1.loc[log_df_1['skip_2']==True].groupby(['session_id'])[col_nonbool].agg(['mean', 'std', 'median'])],\n",
    "                                            axis = 1)\n",
    "    log_df_1_summary_skip2True.columns = log_df_1_summary_skip2True.columns.get_level_values(0)+'_sk2True_'+log_df_1_summary_skip2True.columns.get_level_values(1)\n",
    "    \n",
    "    # aggregate the track history where ['skip_2']==False\n",
    "    log_df_1_summary_skip2False = pd.concat([log_df_1.loc[log_df_1['skip_2']==False].groupby(['session_id'])[col_bool].agg(['mean']), \n",
    "                                             log_df_1.loc[log_df_1['skip_2']==False].groupby(['session_id'])[col_nonbool].agg(['mean', 'std', 'median'])],\n",
    "                                             axis = 1)\n",
    "    log_df_1_summary_skip2False.columns = log_df_1_summary_skip2False.columns.get_level_values(0)+'_sk2False_'+log_df_1_summary_skip2False.columns.get_level_values(1)\n",
    "    \n",
    "    \n",
    "    log_df_history = log_df_1[['session_id','track_id_clean','skip_2','clus']]\n",
    "\n",
    "\n",
    "    half_cut = log_df['session_length']/2\n",
    "\n",
    "\n",
    "    log_df_2 = log_df.loc[(log_df['session_position']>half_cut)]\n",
    "    log_df_2 = log_df_2[['session_id','track_id_clean','skip_2','session_position','session_length','clus']]\n",
    "    log_df_2 = log_df_2.merge(log_df_1_summary_skip2True, on='session_id')\n",
    "    log_df_2 = log_df_2.merge(log_df_1_summary_skip2False, on='session_id')\n",
    "    \n",
    "\n",
    "    sim_file_list = ['../models/SVD/all_tracks/'+simFolder+'/k300_CanbDist.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_CosSim.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_LinCorr.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_ManhDist.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_HammDist.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_SpearCorr.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_KendCorr.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_ChebDist.csv',\n",
    "                     '../models/SVD/all_tracks/'+simFolder+'/k300_BrayDist.csv']\n",
    "    score_name_list = ['CanbDist300', 'CosSim300','LinCorr300','ManhDist300','HammDist300','SpearCorr300','KendCorr300','ChebDist','BrayDist']\n",
    "\n",
    "    return mf.get_sim(log_df_history, log_df_2, sim_file_list, score_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a4a3b038",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Runtime per batch: 89.85s\n",
      "Runtime per batch: 111.45s\n",
      "Runtime per batch: 135.19s\n",
      "Runtime per batch: 170.25s\n",
      "Runtime per batch: 331.45s\n",
      "Runtime per batch: 259.05s\n",
      "Runtime per batch: 265.39s\n"
     ]
    }
   ],
   "source": [
    "# predict the skipping behavior based on the fitted model\n",
    "\n",
    "from timeit import default_timer as timer #to see how long the computation will take\n",
    "\n",
    "ap_list = []\n",
    "first_pred_acc_list = []\n",
    "acc_list = []\n",
    "\n",
    "simFolder_list = ['similarity_20180917-20180917',\n",
    "                  'similarity_20180916-20180917',\n",
    "                  'similarity_20180915-20180917',\n",
    "                  'similarity_20180914-20180917',\n",
    "                  'similarity_20180913-20180917',\n",
    "                  'similarity_20180912-20180917',\n",
    "                  'similarity_20180911-20180917']\n",
    "\n",
    "\n",
    "for (nFile, simFolder) in zip([10,20,30,40,50,60,70], simFolder_list):\n",
    "    model_filename = '../models/SVD/LightGBM_BayesOpt_dec17/for20180918/boost_alltracks_incrementalTrain_'+str(int(nFile))+'_multidays_jan14.txt'\n",
    "\n",
    "    df_lookup_list = []\n",
    "    for file in file_list[0:1]:\n",
    "        start = timer()\n",
    "        df_lookup_list.append(prep_dfs_eval(file, tf_df, simFolder, kmean300_df))\n",
    "\n",
    "    df_lookup = pd.concat(df_lookup_list)\n",
    "    df_lookup = df_lookup.merge(tf_df.drop(columns = ['key','time_signature','mode']))\n",
    "    \n",
    "    \n",
    "    prev_feature_names = lgb.Booster(model_file='../models/SVD/LightGBM_BayesOpt_dec17/for20180918/boost_alltracks_incrementalTrain_5_multidays_jan14.txt').feature_name()\n",
    "    if bool(set(prev_feature_names) - set(df_lookup.columns)): # if there are missing columns\n",
    "        df_lookup[list(set(prev_feature_names) - set(df_lookup.columns))] = 0 # add the missed columns with 0\n",
    "\n",
    "    if bool(set(df_lookup.columns)- set(prev_feature_names)): # if there are extra columns\n",
    "        extra_cols = list(set(df_lookup.columns)- set(prev_feature_names) - set(['session_id','track_id_clean','skip_2','weight']))\n",
    "        df_lookup.drop(columns = extra_cols, inplace = True)\n",
    "            \n",
    "\n",
    "    df_lookup.sort_values(['session_id','session_position'], inplace = True)\n",
    "    df_test = df_lookup.drop(columns = ['session_id','track_id_clean','skip_2']).astype('float32')\n",
    "    X = df_lookup.drop(columns = ['session_id','track_id_clean','skip_2']).to_numpy()\n",
    "\n",
    "    # As it is too slow to calculate the AP of all the sessions in a file. I picked the first 10000 tracks as the validation dataset.\n",
    "    s_list = df_lookup['session_id'].unique()[0:10000]\n",
    "    sel_row = df_lookup['session_id'].isin(s_list)\n",
    "    ytrue = df_lookup['skip_2']\n",
    "    \n",
    "    # check whether the column names match with the previous training set\n",
    "    prev_feature_names = lgb.Booster(model_file=model_filename).feature_name()\n",
    "    if bool(set(prev_feature_names) - set(df_lookup.columns)): # if there are missing columns\n",
    "                df_lookup[list(set(prev_feature_names) - set(df_lookup.columns))] = 0 # add the missed columns with 0\n",
    "\n",
    "    if bool(set(df_lookup.columns)- set(prev_feature_names)): # if there are extra columns\n",
    "        extra_cols = list(set(df_lookup.columns)- set(prev_feature_names) - set(['session_id','track_id_clean','skip_2','weight']))\n",
    "        df_lookup.drop(columns = extra_cols, inplace = True)\n",
    "\n",
    "    bst = lgb.Booster(model_file=model_filename)  # init model\n",
    "\n",
    "    ypred = bst.predict(X)\n",
    "    print('Runtime per batch: %0.2fs' % (timer() - start))\n",
    "\n",
    "    \n",
    "    ap,first_pred_acc  = mf.spotify_eval(ytrue[sel_row], ypred[sel_row]>0.5, df_lookup.loc[sel_row])\n",
    "    ap_list.append(ap)\n",
    "    first_pred_acc_list.append(first_pred_acc)\n",
    "    acc_list.append(accuracy_score(ypred>0.5, ytrue*1))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "223cba20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ap</th>\n",
       "      <th>first_pred_acc</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>days</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.570301</td>\n",
       "      <td>0.7439</td>\n",
       "      <td>0.676969</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.480130</td>\n",
       "      <td>0.6406</td>\n",
       "      <td>0.603045</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.418117</td>\n",
       "      <td>0.5566</td>\n",
       "      <td>0.540535</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.545224</td>\n",
       "      <td>0.7295</td>\n",
       "      <td>0.654290</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.547508</td>\n",
       "      <td>0.7308</td>\n",
       "      <td>0.656072</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.546973</td>\n",
       "      <td>0.7316</td>\n",
       "      <td>0.655881</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0.546749</td>\n",
       "      <td>0.7311</td>\n",
       "      <td>0.654613</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         ap  first_pred_acc  accuracy  days\n",
       "0  0.570301          0.7439  0.676969     1\n",
       "1  0.480130          0.6406  0.603045     2\n",
       "2  0.418117          0.5566  0.540535     3\n",
       "3  0.545224          0.7295  0.654290     4\n",
       "4  0.547508          0.7308  0.656072     5\n",
       "5  0.546973          0.7316  0.655881     6\n",
       "6  0.546749          0.7311  0.654613     7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# results = pd.DataFrame({'ap': ap_list, 'first_pred_acc': first_pred_acc_list, 'days':[1,2,3,4,5,6,7]})\n",
    "results = pd.DataFrame({'ap':ap_list, 'first_pred_acc':first_pred_acc_list, 'accuracy':acc_list, 'days':[1,2,3,4,5,6,7]})\n",
    "\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53dcdc63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(figsize=(6,6), nrows=2) \n",
    "\n",
    "graph1 = sns.lineplot(y='ap', x='days', data=results, ax=ax1, hue=True, style = True, markers = True, legend = False)\n",
    "# ax1.set_xticks([1,2,3])\n",
    "ax1.set_ylabel('AP')\n",
    "ax1.set_xlabel(\"number of days' data\")\n",
    "graph1.axhline(0.334, linestyle = '--', c = 'k', label='baseline')\n",
    "ax1.legend(loc ='upper right')\n",
    "ax1.set_ylim(0.3,0.6)\n",
    "\n",
    "graph2 = sns.lineplot(y='first_pred_acc', x='days', data=results, ax=ax2, hue=True, style = True, markers = True, legend = False)\n",
    "# ax2.set_xticks([1,2,3])\n",
    "ax2.set_ylabel('First prediction accuracy')\n",
    "ax2.set_xlabel(\"number of days' data\")\n",
    "graph2.axhline(0.5, linestyle = '--', c = 'k', label='baseline')\n",
    "ax2.legend(loc ='upper right')\n",
    "ax2.set_ylim(0.45,0.8)\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e56a1bf8",
   "metadata": {},
   "source": [
    "Although all the model performances were above the baselines, it was clear that the prediction performance was the best when only including the training data from 1 day before. The performance dropped significantly when the training data spanned to 2 or 3 days before. The model performance increased again when adding more older data, the but performance did not reach the best \n",
    "\n",
    "A possible explanation is that the information from the days further away are more different to the validation dataset. Therefore, adding 2 or 3 days' of data before the validation dataset into the model was like adding noise. This situation could be mitigated when adding sufficient amount of older data, as some subtle patterns might emerge with sufficient amount of \"noise\". However, the benefit of adding more older data can grow very slowly, and not yet reached the level of data of 1 day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a9ec78a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}