03_01_lgbmRanker_covisit.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "072f7899",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "04-03-23 - Added if statements for DO_LOCAL_VAL. Now test and cv use same pipeline\n",
    "04-02-23 - For getting test preds, don't need to downsample or train\n",
    "         - X*Make extra script for just getting final test preds\n",
    "         - X*Maybe we can if statement the downsample and train part\n",
    "           This is useful to reduce human error in using the same data pipeline\n",
    "04-01-23 - To compare HP sweeps, should only look at clicks/carts/orders, not overall\n",
    "         - Updated lgbm code to use for loop. Made d_preds do clicks, carts, orders\n",
    "03-27-23 - Removed get_cands50 code. Instead, using suggest_preds with num_cand=50\n",
    "03-27-23 - 2 parts, the CV, and the final preds for test\n",
    "           *How to split the two? should probably use 1 nb? Memory usage?\n",
    "03-26-23 - Moved get_recall into otto_utils.py\n",
    "03-21-23 - Moved covisit preprocessing into function\n",
    "         - Created test_aids_types.pkl file so we load instead of process\n",
    "03-20-23 - Removed LGBM code\n",
    "03-18-23 - Created separate val data in pkl dictionary\n",
    "         - Now uniformly sampled across the week instead of chronologically\n",
    "03-17-23 - Couldn't get starmap or partial+map to work faster than orig method\n",
    "03-17-23 - Moved covisit code into otto_utils.py\n",
    "03-16-23 - Make covisit preprocess indep func.\n",
    "\"\"\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bc37ce8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Pandarallel will run on 8 workers.\n",
      "INFO: Pandarallel will use Memory file system to transfer data between the main process and workers.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from collections import Counter\n",
    "import warnings\n",
    "from itertools import product\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from pandarallel import pandarallel\n",
    "import mlflow\n",
    "\n",
    "from otto_utils import trange, preprocess_covisits, get_preds, get_recall\n",
    "# Below are ranker functions\n",
    "from otto_utils import iterate_dict, create_config\n",
    "from otto_utils import get_cands_pl, make_feats_radek_pl, make_all_feats_pl\n",
    "from otto_utils import downsample_neg, train_lgbm, get_preds_lgbm\n",
    "\n",
    "pandarallel.initialize(progress_bar=False)\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4a2fabf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keeping suggests in main notebook for speed. Tried moving to utils.py, but\n",
    "# could not match equivalent speed. Funcs need top_20_clicks/buys/buy2buy\n",
    "num_cands = 50\n",
    "def suggest_clicks(event, num_cands=num_cands, type_weights1={0: 0.5, 1: 9, 2:0.5}):\n",
    "    \"\"\" Get click suggestions, uses top_20_clicks & popul_20_clicks \"\"\"\n",
    "    aids, types = event\n",
    "    unique_aids = list(dict.fromkeys(aids[::-1]))\n",
    "    # RERANK CANDIDATES USING WEIGHTS\n",
    "    if len(unique_aids) >= num_cands:\n",
    "        time_weights = np.logspace(0.1,1,len(aids),base=2, endpoint=True)-1\n",
    "        aids_temp = {}\n",
    "        # RERANK BASED ON REPEAT ITEMS AND TYPE OF ITEMS\n",
    "        for time_w, aid, type_aid in zip(time_weights, aids, types):\n",
    "            type_w = type_weights1[type_aid]\n",
    "            aids_temp[aid] = aids_temp.get(aid, 0) + time_w*type_w\n",
    "        sorted_aids = [k for k,v in sorted(aids_temp.items(), key=lambda x: x[1], reverse=True)]\n",
    "        return sorted_aids[:num_cands]\n",
    "    # USE \"CLICKS\" CO-VISITATION MATRIX\n",
    "    candidates = []\n",
    "    for aid in unique_aids: # most recent AID is first here\n",
    "        if aid in top_20_clicks:\n",
    "            candidates.extend(top_20_clicks[aid])\n",
    "    # RERANK CANDIDATES\n",
    "    top_candidates = []\n",
    "    for candidate, _ in Counter(candidates).most_common(num_cands):\n",
    "        if candidate not in unique_aids:\n",
    "            top_candidates.append(candidate)\n",
    "    result = unique_aids + top_candidates[:num_cands-len(unique_aids)]\n",
    "    set_result = set(result)\n",
    "    result += [i for i in popul_20_clicks if i not in set_result][:num_cands - len(result)]\n",
    "    return result\n",
    "\n",
    "def suggest_carts(event, num_cands=num_cands, type_weights1={0: 0.5, 1: 9, 2:0.5}):\n",
    "    \"\"\" Get carts & orders suggestions, uses top_20_clicks/buys/buy2buy & popul_20_carts \"\"\"\n",
    "    aids, types = event\n",
    "    unique_aids = list(dict.fromkeys(aids[::-1])) # \"\"\"\"\"\"\n",
    "    unique_buys = [aid for aid, typ in zip(aids, types) if typ<2][::-1]\n",
    "    unique_buys = list(dict.fromkeys(unique_buys)) # idx=0 = most recent\n",
    "    # RERANK CANDIDATES USING WEIGHTS\n",
    "    if len(unique_aids) >= 20: # \"\"\"\"\"\"\n",
    "        time_weights=np.logspace(0.5,1,len(aids),base=2, endpoint=True)-1\n",
    "        aids_temp = {}\n",
    "        # RERANK BASED ON REPEAT ITEMS AND TYPE OF ITEMS\n",
    "        for time_w, aid, type_aid in zip(time_weights, aids, types):\n",
    "            type_w = type_weights1[type_aid]\n",
    "            aids_temp[aid] = aids_temp.get(aid, 0) + time_w*type_w\n",
    "        # RERANK CANDIDATES USING \"BUYS\" CO-VISITATION MATRIX\n",
    "        candidates = []\n",
    "        for aid in unique_buys: #\"\"\"weight top 20 buys from covisit matrix\"\"\"\n",
    "            if aid in top_20_buys:\n",
    "                candidates.extend(top_20_buys[aid])\n",
    "        for candidate in candidates:\n",
    "            aids_temp[candidate] = aids_temp.get(candidate, 0) + 0.03\n",
    "        sorted_aids = [k for k,v in sorted(aids_temp.items(), key=lambda x: x[1], reverse=True)]\n",
    "        return sorted_aids[:num_cands]\n",
    "    # USE \"CART ORDER\" CO-VISITATION MATRIX\n",
    "    candidates1, candidates2, candidates3 = [], [], []\n",
    "    for aid in unique_aids: # most recent AID is first here\n",
    "        if aid in top_20_buys:\n",
    "            candidates1.extend(top_20_buys[aid])\n",
    "    # USE \"CLICKS\" CO-VISITATION MATRIX\n",
    "    for aid in unique_buys: # most recent AID is first here\n",
    "        if aid in top_20_clicks:\n",
    "            candidates2.extend(top_20_clicks[aid])\n",
    "    for aid in unique_buys: # most recent AID is first here\n",
    "        if aid in top_20_buy2buy:\n",
    "            candidates3.extend(top_20_buy2buy[aid])\n",
    "    # RERANK CANDIDATES\n",
    "    top_candidates = []\n",
    "    # \"\"\"Deote uses 20 instead of 40 here\"\"\"\n",
    "    for candidate, _ in Counter(candidates1+candidates2+candidates3).most_common(num_cands):\n",
    "        if candidate not in unique_aids: top_candidates.append(candidate)\n",
    "    result = unique_aids + top_candidates[:num_cands-len(unique_aids)]\n",
    "    set_result = set(result)\n",
    "    result += [i for i in popul_20_carts if i not in set_result][:num_cands - len(result)]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9ff6ab46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-07-31 22:00:00\n",
      "2022-09-04 21:59:51\n",
      "34 days 23:59:51\n",
      "*Start covisit preprocessing\n",
      "top_20_clicks already exists\n",
      "top_20_buys already exists\n",
      "top_20_buy2buy already exists\n",
      "*Finished covisit preprocessing\n",
      "5015409\n",
      "(163555218, 4) (6928123, 4)\n"
     ]
    }
   ],
   "source": [
    "# 0: 5%, 1: 10%, 2: 25%, 3: 50%, 4: 100%\n",
    "CV_NUM = 4\n",
    "DO_LOCAL_VALIDATION=True\n",
    "# DO_LOCAL_VALIDATION=False\n",
    "DATE = 230313\n",
    "\n",
    "## 3-15-23 Adding back covisit matrix code\n",
    "# Data + data_test had best covisit matrix performance\n",
    "data = pd.read_parquet('data/230313_df_train.pqt')\n",
    "data_test = pd.read_parquet('data/230313_df_test.pqt')\n",
    "d_id2type = pd.read_pickle('data/d_id2type.pkl')\n",
    "d_type2id = pd.read_pickle('data/d_type2id.pkl')\n",
    "df_all_sm = pd.concat([data, data_test]).reset_index(drop=True)\n",
    "trange(df_all_sm)\n",
    "\n",
    "# Make all covisit matrices if they do not exist\n",
    "preprocess_covisits(df_all_sm, DATE)\n",
    "\n",
    "top_20_clicks = pd.read_pickle(f'covisit/{DATE}_top_20_clicks_data_datatest.pkl')\n",
    "top_20_buys = pd.read_pickle(f'covisit/{DATE}_top_20_buys_data_datatest.pkl')\n",
    "top_20_buy2buy = pd.read_pickle(f'covisit/{DATE}_top_20_buy2buy_data_datatest.pkl')\n",
    "\n",
    "if DO_LOCAL_VALIDATION:\n",
    "    # Train weeks 1-3, and validate on 4\n",
    "    df_train = pd.read_parquet('data/230313_train_1to3.pqt')\n",
    "    df_val = pd.read_parquet('data/230313_val.pqt')\n",
    "    d = pd.read_pickle(f'data/preload/{DATE}_val_aids_types_{CV_NUM}.pkl')\n",
    "    test_aids, test_types = d['aids'], d['types']\n",
    "else:\n",
    "    # Keep train to 4 weeks to maintain input distribution for LGBMranker\n",
    "    # Train weeks 2-4, validate on 4 (for sanity check)\n",
    "    df_train = pd.read_parquet('data/230313_train_2to4.pqt')\n",
    "    df_val = pd.read_parquet('data/230313_df_test.pqt')\n",
    "    d = pd.read_pickle('data/preload/test_aids_types.pkl')\n",
    "    test_aids, test_types = d['aids'], d['types']\n",
    "\n",
    "t = list(zip(test_aids, test_types))\n",
    "print(len(t)*3)\n",
    "print(df_train.shape, df_val.shape)\n",
    "\n",
    "## {0: 'clicks', 1: 'carts', 2: 'orders'}\n",
    "popul_20_clicks = df_val.loc[df_val['type']==0,'aid'].value_counts().index.values[:20].tolist()\n",
    "popul_20_carts = df_val.loc[df_val['type']== 1,'aid'].value_counts().index.values[:20].tolist()\n",
    "popul_20_orders = df_val.loc[df_val['type']==2,'aid'].value_counts().index.values[:20].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ab57bd0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 38.2 s, sys: 7.93 s, total: 46.2 s\n",
      "Wall time: 1min 1s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pclicks = get_preds(t, suggest_clicks)\n",
    "pcarts = get_preds(t, suggest_carts)\n",
    "preds = pclicks + pcarts + pcarts\n",
    "\n",
    "pclicks20 = [x[:20] for x in pclicks]\n",
    "pcarts20 = [x[:20] for x in pcarts]\n",
    "preds20 = pclicks20 + pcarts20 + pcarts20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "872d695a",
   "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>session</th>\n",
       "      <th>type</th>\n",
       "      <th>labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12899779</td>\n",
       "      <td>clicks</td>\n",
       "      <td>59625 1253524 737445 438191 731692 1790770 942...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>12899780</td>\n",
       "      <td>clicks</td>\n",
       "      <td>1142000 736515 973453 582732 1502122 889686 48...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>12899781</td>\n",
       "      <td>clicks</td>\n",
       "      <td>918667 199008 194067 57315 141736 1460571 7594...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    session    type                                             labels\n",
       "0  12899779  clicks  59625 1253524 737445 438191 731692 1790770 942...\n",
       "1  12899780  clicks  1142000 736515 973453 582732 1502122 889686 48...\n",
       "2  12899781  clicks  918667 199008 194067 57315 141736 1460571 7594..."
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess = test_aids.index.to_list()\n",
    "sub = {'session': sess*3,\n",
    "       'type': ['clicks']*len(sess) + ['carts']*len(sess) + ['orders']*len(sess)\n",
    "      }\n",
    "submission = pd.DataFrame(sub)\n",
    "\n",
    "if DO_LOCAL_VALIDATION:\n",
    "    submission['labels'] = preds\n",
    "else:\n",
    "    l_preds = [' '.join([str(l) for l in lls]) for lls in preds]\n",
    "    submission['labels'] = l_preds\n",
    "submission.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3fe4153b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================\n",
      "clicks Recall: 0.6425\n",
      "carts Recall: 0.5051\n",
      "orders Recall: 0.6914\n",
      "======================\n",
      "Overall Recall: 0.63064\n",
      "======================\n",
      "CPU times: user 6.71 s, sys: 2.46 s, total: 9.17 s\n",
      "Wall time: 17.4 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.6424781171022736,\n",
       " 0.5051080625090656,\n",
       " 0.6914356279083776,\n",
       " 0.6306416072079737)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "# Compare covisit 20 and 50 cand recall\n",
    "if DO_LOCAL_VALIDATION:\n",
    "    get_recall(submission, DO_LOCAL_VALIDATION, DATE)\n",
    "    submission['labels'] = preds20\n",
    "    get_recall(submission, DO_LOCAL_VALIDATION, DATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b17e3d18",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "INFO = \"0307 refactored covisit with lgbmranker carts and orders, no embeddings\"\n",
    "s = f\"kaggle competitions submit -c otto-recommender-system -f submission.zip -m '{INFO}'\"\n",
    "os.system(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dae15bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "94e7295b",
   "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>MDL</th>\n",
       "      <th>recall</th>\n",
       "      <th>r_click</th>\n",
       "      <th>r_cart</th>\n",
       "      <th>r_order</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>{'num_splits': 5, 'num_avg': 1, 'neg_frac': 0....</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                 MDL  recall  r_click  r_cart  \\\n",
       "0  {'num_splits': 5, 'num_avg': 1, 'neg_frac': 0....     0.0        0       0   \n",
       "\n",
       "   r_order  \n",
       "0        0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# START LGBM SECTION\n",
    "# Notes: To get best HP, sweep and sort by atype, and use the\n",
    "# HPs for best scores for each atype. DO NOT USE OVERALL RECALL***\n",
    "# Make a dictionary of model hyperparameter sweeps\n",
    "# Then permute with data preprocessing hyperparameters\n",
    "def create_model_configs(model)->dict:\n",
    "    if model == 'lgbm':\n",
    "        d = {'model': ['lgbm'], # baseline highest score with extra trees\n",
    "             'boosting_type': ['gbdt'], # ['gbdt', 'dart']\n",
    "             'n_estimators': [499,],\n",
    "             'subsample': [0.8,],\n",
    "             'subsample_freq': [1],\n",
    "             'learning_rate': [0.1,],\n",
    "             'num_leaves': [50], # less than 2^max_depth\n",
    "             'min_data_in_leaf': [100],\n",
    "             'max_depth': [6,],\n",
    "             'is_unbalance': [False],\n",
    "#              'extra_trees': [False, True], # False is better\n",
    "             'boost_from_average': [True], # default True\n",
    "             'early_stopping': [50],\n",
    "             'verbose': [-1],\n",
    "             'random_state': [42],\n",
    "             'device': ['gpu'],\n",
    "             'gpu_platform_id': [0],\n",
    "             'gpu_device_id': [0], # a6000 = device_id 0\n",
    "            }\n",
    "    \n",
    "    keys, values = zip(*d.items()) # Gets keys and values in deterministic order\n",
    "    df_config = pd.DataFrame(list(product(*values)), columns=keys)\n",
    "    d_configs = df_config.to_dict('records')\n",
    "    return d_configs\n",
    "\n",
    "cfgl = create_model_configs('lgbm')\n",
    "cfgs = cfgl\n",
    "\n",
    "d_mdl = {\n",
    "    'num_splits': [5],\n",
    "    'num_avg': [1], # number of folds to use and then avg. Use 1 for max speed\n",
    "    'neg_frac': [0.3,],\n",
    "    'metric': ['map'],\n",
    "    'eval_at': [20],\n",
    "    'MDL': cfgs\n",
    "    }\n",
    "\n",
    "d = {'MDL': iterate_dict(d_mdl)}\n",
    "df_config = create_config(d)\n",
    "df_config['recall'] = 0.\n",
    "df_config['r_click'], df_config['r_cart'], df_config['r_order'] = 0, 0, 0\n",
    "df_config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "346e69bd",
   "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>session</th>\n",
       "      <th>ts</th>\n",
       "      <th>type</th>\n",
       "      <th>aid</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12899779</td>\n",
       "      <td>1661724000</td>\n",
       "      <td>0</td>\n",
       "      <td>59625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>12899780</td>\n",
       "      <td>1661724000</td>\n",
       "      <td>0</td>\n",
       "      <td>1142000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>12899780</td>\n",
       "      <td>1661724058</td>\n",
       "      <td>0</td>\n",
       "      <td>582732</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    session          ts  type      aid\n",
       "0  12899779  1661724000     0    59625\n",
       "1  12899780  1661724000     0  1142000\n",
       "2  12899780  1661724058     0   582732"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Minor preprocessing hacks to get loop working. Refactor in future\n",
    "# Put preds into dictionary, so we can adjust predictions after fitting lgbm\n",
    "dpreds = {'clicks': pclicks20, 'carts': pcarts, 'orders': pcarts}\n",
    "\n",
    "# Grab relevant sessions because we subsampled sessions for speed\n",
    "df_val_cv = df_val[df_val.session.isin(sess)].reset_index(drop=True)\n",
    "df_val_cv.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "caafbed0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***Starting carts\n",
      "carts Density: 0.00000\n",
      "pred fold: 0\n",
      "***Starting orders\n",
      "orders Density: 0.00000\n",
      "pred fold: 0\n",
      "CPU times: user 1h 5min, sys: 1min 52s, total: 1h 6min 52s\n",
      "Wall time: 9min 34s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# LOG = True\n",
    "LOG = False\n",
    "\n",
    "# for atype in ['clicks', 'carts', 'orders']:\n",
    "for atype in ['carts', 'orders']:\n",
    "# for atype in ['carts']:\n",
    "    print(f'***Starting {atype}')\n",
    "    # 1) Get features for candidates\n",
    "    # Make user, item, user-item, covisit features\n",
    "    grps = [len(x) for x in pcarts]\n",
    "    dfc = get_cands_pl(pcarts, df_train, df_val_cv, atype, grps, DATE)\n",
    "    df_val_r = make_feats_radek_pl(df_val_cv)\n",
    "    dfc = make_all_feats_pl(dfc, df_val_r, atype)\n",
    "    dfc = dfc.sort(by=['user', 'ts'])\n",
    "    dfc = dfc.to_pandas()\n",
    "    # Fillna\n",
    "    cols_fillna = ['session_length', 'action_num_reverse_chrono', 'log_recency_score', ]\n",
    "    for col in cols_fillna:\n",
    "        dfc[col] = dfc[col].fillna(-1)\n",
    "    # Change datatypes to save memory\n",
    "    dfc['ts'] = dfc['ts'].astype('float32')\n",
    "    dfc['type'] = dfc['type'].astype('float16')\n",
    "    dfc['session_length'] = dfc['session_length'].astype('float16')\n",
    "    dfc['action_num_reverse_chrono'] = dfc['action_num_reverse_chrono'].astype('float16')\n",
    "    print(f'{atype} Density: {dfc[atype].sum()/len(dfc):0.5f}')\n",
    "    \n",
    "    ############# START LGMB TRAINING #############\n",
    "    cols_remove = ['user', 'item', 'carts', 'clicks', 'orders', 'ts', 'type',]\n",
    "    feats = [col for col in dfc.columns if col not in cols_remove]\n",
    "    train_plots = []\n",
    "\n",
    "    for CFG in df_config.itertuples():\n",
    "        try:\n",
    "            with mlflow.start_run(experiment_id = None,\n",
    "                                  run_name=''):\n",
    "                if LOG and DO_LOCAL_VALIDATION:\n",
    "                    mlflow.log_params({k:v for k,v in CFG.MDL.items() if k!='MDL'})\n",
    "                    mlflow.log_params(CFG.MDL['MDL'])\n",
    "                    mlflow.log_params({'atype': atype})\n",
    "\n",
    "                ###### Code\n",
    "                if DO_LOCAL_VALIDATION:\n",
    "                    dfc_sm = downsample_neg(dfc, atype, CFG.MDL['neg_frac'])\n",
    "                    ranker, train_curves = train_lgbm(dfc_sm, atype, feats, CFG.MDL)\n",
    "                    train_plots.append(train_curves)\n",
    "\n",
    "                dpreds[atype] = get_preds_lgbm(dfc, feats, atype, CFG.MDL)\n",
    "                preds = dpreds['clicks'] + dpreds['carts'] + dpreds['orders']\n",
    "                \n",
    "                if DO_LOCAL_VALIDATION:\n",
    "                    submission['labels'] = preds\n",
    "                    r_click, r_cart, r_order, recall = get_recall(submission, \n",
    "                                                                  DO_LOCAL_VALIDATION,\n",
    "                                                                  DATE)\n",
    "                    avg_last=20\n",
    "                    mmap = np.mean(ranker.evals_result_['valid_0'][f\"{CFG.MDL['metric']}@{CFG.MDL['eval_at']}\"][-avg_last:])\n",
    "\n",
    "                    df_config.loc[CFG.Index, 'recall'] = recall\n",
    "                    df_config.loc[CFG.Index, 'r_click'] = r_click\n",
    "                    df_config.loc[CFG.Index, 'r_cart'] = r_cart\n",
    "                    df_config.loc[CFG.Index, 'r_order'] = r_order\n",
    "                    df_config.loc[CFG.Index, 'map'] = mmap\n",
    "                    if LOG and DO_LOCAL_VALIDATION:\n",
    "                        metrics = {\n",
    "                            'r_click': r_click,\n",
    "                            'r_carts': r_cart, \n",
    "                            'r_orders': r_order,\n",
    "                            'recall': recall,\n",
    "                            'stop_iter': len(ranker.evals_result_['valid_0'][f\"{CFG.MDL['metric']}@{CFG.MDL['eval_at']}\"]),\n",
    "                            'map': mmap\n",
    "                        }\n",
    "                        mlflow.log_metrics(metrics)         \n",
    "        except:\n",
    "            print('error')\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7b266719",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Postprocess for LGBM+covisit test submission\n",
    "l_preds = [' '.join([str(l) for l in lls]) for lls in preds]\n",
    "submission['labels'] = l_preds\n",
    "get_recall(submission, DO_LOCAL_VALIDATION, DATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9990203f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: Looks like you're using an outdated API Version, please consider updating (server 1.5.13 / client 1.5.12)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 344M/344M [03:58<00:00, 1.51MB/s]   "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully submitted to OTTO – Multi-Objective Recommender SystemCPU times: user 443 ms, sys: 131 ms, total: 574 ms\n",
      "Wall time: 4min\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "INFO = \"0307 lgbm+covisit refactored covisit with lgbmranker carts and orders, no embeddings\"\n",
    "s = f\"kaggle competitions submit -c otto-recommender-system -f submission.zip -m '{INFO}'\"\n",
    "os.system(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cabac557",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================\n",
      "clicks Recall: 0.5912\n",
      "carts Recall: 0.4304\n",
      "orders Recall: 0.6445\n",
      "======================\n",
      "Overall Recall: 0.57494\n",
      "======================\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.5912450178094085,\n",
       " 0.4303918649657605,\n",
       " 0.6445010014607774,\n",
       " 0.5749426621471354)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare after LGBM preds with p20, not p50\n",
    "submission['labels'] = preds20\n",
    "get_recall(submission, DO_LOCAL_VALIDATION, DATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ba6059a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e10b87cd",
   "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
}