final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Imports\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import category_encoders\n",
    "from sklearn.model_selection import GroupKFold,TimeSeriesSplit\n",
    "import hyperopt\n",
    "from hyperopt import hp, tpe, STATUS_OK, Trials\n",
    "import pickle\n",
    "import gensim\n",
    "import lightgbm as lgb\n",
    "from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Data Sources\n",
    "train=pd.read_csv('train.csv')\n",
    "test=pd.read_csv('test_QyjYwdj.csv')\n",
    "campaign_data=pd.read_csv('campaign_data.csv')\n",
    "coupon_item_mapping=pd.read_csv('coupon_item_mapping.csv')\n",
    "customer_demographics=pd.read_csv('customer_demographics.csv')\n",
    "item_data=pd.read_csv('item_data.csv')\n",
    "customer_transaction_data=pd.read_csv('customer_transaction_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Mege train and test set with campaign information\n",
    "train_campaign=train.merge(campaign_data,on='campaign_id')\n",
    "test_campaign=test.merge(campaign_data,on='campaign_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Use convert to datetime and use dayfirst=True to correct the date\n",
    "train_campaign['start_date']=pd.to_datetime(train_campaign['start_date'],dayfirst=True)\n",
    "train_campaign['end_date']=pd.to_datetime(train_campaign['end_date'],dayfirst=True)\n",
    "test_campaign['start_date']=pd.to_datetime(test_campaign['start_date'],dayfirst=True)\n",
    "test_campaign['end_date']=pd.to_datetime(test_campaign['end_date'],dayfirst=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Generate features from coupon item mapping\n",
    "## 3 features : Unique items, brands, brand types in a coupon\n",
    "coupon_item_data=coupon_item_mapping.merge(item_data,on='item_id',how='left')\n",
    "unique_item_data=pd.DataFrame(coupon_item_data.groupby('coupon_id')['item_id','brand','brand_type'].agg(['unique']).reset_index())\n",
    "unique_item_data.columns=['coupon_id','item_id_uniq','brand_uniq','brand_type_uniq']\n",
    "unique_item_data['item_id_uniq']=[len(i) for i in unique_item_data['item_id_uniq']]\n",
    "unique_item_data['brand_uniq']=[len(i) for i in unique_item_data['brand_uniq']]\n",
    "unique_item_data['brand_type_uniq']=[len(i) for i in unique_item_data['brand_type_uniq']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Merge train and test set with customer demographics\n",
    "train_demo=train_campaign.merge(customer_demographics,on='customer_id',how='left')\n",
    "test_demo=test_campaign.merge(customer_demographics,on='customer_id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Fill ordinal categories with appropriate values for the model to be able to learn them\n",
    "train_demo['family_size']=train_demo['family_size'].replace({'1':1, '2':2, '3':3, '4':4 ,'5+':5})\n",
    "train_demo['no_of_children']=train_demo['no_of_children'].replace({'1':1, '2':2, '3+':3})\n",
    "train_demo['age_range']=train_demo['age_range'].replace({'18-25':1,'26-35':2,'36-45':3,'46-55':4,'56-70':5,'70+':6})\n",
    "train_demo['marital_status']=train_demo['marital_status'].replace({'Married':0,'Single':1})\n",
    "test_demo['family_size']=test_demo['family_size'].replace({'1':1, '2':2, '3':3, '4':4 ,'5+':5})\n",
    "test_demo['no_of_children']=test_demo['no_of_children'].replace({'1':1, '2':2, '3+':3})\n",
    "test_demo['age_range']=test_demo['age_range'].replace({'18-25':1,'26-35':2,'36-45':3,'46-55':4,'56-70':5,'70+':6})\n",
    "test_demo['marital_status']=test_demo['marital_status'].replace({'Married':0,'Single':1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Encode campaign type\n",
    "lb=LabelEncoder()\n",
    "train_demo['campaign_type']=lb.fit_transform(train_demo['campaign_type'])\n",
    "test_demo['campaign_type']=lb.transform(test_demo['campaign_type'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols=['campaign_type','age_range',\n",
    "       'marital_status', 'rented', 'family_size', 'no_of_children',\n",
    "       'income_bracket']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \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: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "## Cleaning the date in the transaction data, filtering it out only on valid items in coupon item mapping\n",
    "uniq_items=coupon_item_mapping['item_id'].unique()\n",
    "relevant_transactions=customer_transaction_data[customer_transaction_data['item_id'].isin(uniq_items)]\n",
    "relevant_transactions['date']=pd.to_datetime(customer_transaction_data['date'],dayfirst=True)\n",
    "customer_transaction_data['date']=pd.to_datetime(customer_transaction_data['date'],dayfirst=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Merging brand information from coupon level data with customer transactions\n",
    "item_brands=coupon_item_data[['item_id','brand']].drop_duplicates()\n",
    "relevant_transactions=relevant_transactions.merge(item_brands,on='item_id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:10: SettingWithCopyWarning: \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: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "9.753772258758545\n"
     ]
    }
   ],
   "source": [
    "## Engineering various customer level features from customer transactions data on past dates to avoid leakage\n",
    "## Some features could be\n",
    "#  1) no of items purchased before current campaign \n",
    "#  2) unique items purchased before current campaign total quantity of all items bought before campaign date\n",
    "#  3) total quantity of all items bought before campaign date\n",
    "#  4) features based on selling price, discounts, other discounts, no of discounts taken before a campaign, etc.\n",
    "start=time.time()\n",
    "count=0\n",
    "df_main=pd.DataFrame()\n",
    "for i in train_demo['start_date'].unique():\n",
    "    count=count+1\n",
    "    print(count)\n",
    "    train_chunk=train_demo[train_demo.start_date==i]\n",
    "    log_temp=relevant_transactions[relevant_transactions.date<i]\n",
    "    log_temp['ratio']=abs(log_temp['coupon_discount']/log_temp['selling_price'])\n",
    "    customer_uniq_item_count=log_temp.groupby(['customer_id'])['item_id'].nunique().reset_index()\n",
    "    customer_uniq_item_count.columns=['customer_id','uniq_item_count']\n",
    "    customer_item_count=log_temp.groupby(['customer_id'])['item_id'].count().reset_index()\n",
    "    customer_item_count.columns=['customer_id','item_count']\n",
    "    customer_total_item_count=log_temp.groupby('customer_id')['quantity'].sum().reset_index()\n",
    "    customer_total_item_count.columns=['customer_id','total_item_count']\n",
    "    discounts_count_coupon=log_temp[log_temp['coupon_discount']<0].groupby('customer_id')['coupon_discount'].count().reset_index()\n",
    "    discounts_count_coupon.columns=['customer_id','disc_count']\n",
    "    discounts_count_other=log_temp[log_temp['other_discount']<0].groupby('customer_id')['other_discount'].count().reset_index()\n",
    "    discounts_count_other.columns=['customer_id','disc_count_other']\n",
    "    cust_price=log_temp.groupby(['customer_id'])['selling_price'].agg(['min','max','mean','sum']).reset_index()\n",
    "    cust_price.columns=['customer_id','min_price','max_price','mean_price','sum']\n",
    "    discounts_feats_coupon=log_temp[log_temp['coupon_discount']<0].groupby('customer_id')['coupon_discount'].agg(['min','max','mean','sum']).reset_index()\n",
    "    discounts_feats_coupon.columns=['customer_id','min_disc','max_disc','mean_disc','sum_disc']\n",
    "    mean_disc_to_price=log_temp[log_temp['coupon_discount']<0].groupby('customer_id')['ratio'].agg(['min','max','mean']).reset_index()\n",
    "    mean_disc_to_price.columns=['customer_id','min_rat','max_rat','mean_rat']\n",
    "    uniq_brands=log_temp.groupby(['customer_id'])['brand'].nunique().reset_index()\n",
    "    uniq_brands.columns=['customer_id','uniq_brand_count']\n",
    "    train_chunk=train_chunk.merge(uniq_brands,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(customer_uniq_item_count,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(customer_item_count,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(discounts_count_coupon,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(discounts_count_other,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(cust_price,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(discounts_feats_coupon,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(mean_disc_to_price,on='customer_id',how='left')\n",
    "    train_chunk=train_chunk.merge(customer_total_item_count,on='customer_id',how='left')\n",
    "    train_chunk['min_disc']=abs(train_chunk['min_disc'])\n",
    "    train_chunk['max_disc']=abs(train_chunk['max_disc'])\n",
    "    train_chunk['mean_disc']=abs(train_chunk['mean_disc'])\n",
    "    train_chunk['sum_disc']=abs(train_chunk['sum_disc'])\n",
    "    df_main=pd.concat([df_main,train_chunk])\n",
    "end=time.time()\n",
    "print(end-start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_main=df_main.sort_values(by='start_date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:19: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n",
      "of pandas will change to not sort by default.\n",
      "\n",
      "To accept the future behavior, pass 'sort=False'.\n",
      "\n",
      "To retain the current behavior and silence the warning, pass 'sort=True'.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Adding moving groupby features on coupon and customer level based on target distribution\n",
    "## Also adding no of customers that have redeemed a coupon as a feature\n",
    "## All featurs made on past data before the campaign in consideration\n",
    "df_target=pd.DataFrame()\n",
    "for i in df_main['start_date'].unique():\n",
    "    chk=df_main[df_main.start_date<i]\n",
    "    chk_2=df_main[df_main.start_date==i]\n",
    "    target_enc = chk.groupby(by = ['coupon_id'])['redemption_status'].agg(['sum','count']).reset_index()\n",
    "    target_enc.columns = ['coupon_id',\"target_sum\",\"target_count\"]\n",
    "    target_enc['encoding_coupon'] = target_enc.target_sum/target_enc.target_count\n",
    "    target_enc_1 = chk.groupby(by = ['customer_id'])['redemption_status'].agg(['sum','count']).reset_index()\n",
    "    target_enc_1.columns = ['customer_id',\"target_sum_1\",\"target_count_1\"]\n",
    "    target_enc_1['encoding_customer'] = target_enc_1.target_sum_1/target_enc_1.target_count_1\n",
    "    chk_2=chk_2.merge(target_enc,on='coupon_id',how='left')\n",
    "    chk_2=chk_2.merge(target_enc_1,on='customer_id',how='left')\n",
    "    try:\n",
    "        people_coupons=chk[chk['redemption_status']==1].groupby('coupon_id')['customer_id'].nunique().reset_index()\n",
    "        people_coupons.columns=['coupon_id','no_of_users']\n",
    "        chk_2=chk_2.merge(people_coupons,on='coupon_id',how='left')\n",
    "    except:\n",
    "        pass\n",
    "    df_target=pd.concat([df_target,chk_2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Overall groupby on training set of target variable on coupon level\n",
    "target_enc1 = df_target.groupby(by = ['coupon_id'])['redemption_status'].agg(['sum','count']).reset_index()\n",
    "target_enc1.columns = ['coupon_id',\"target_sum1\",\"target_count1\"]\n",
    "target_enc1['encoding'] = target_enc1.target_sum1/target_enc1.target_count1\n",
    "df_target=df_target.merge(target_enc1,on='coupon_id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "## We cannot use item, brand, category, etc directly as features.\n",
    "## So will be adding embeddings created from coupon item mapping for item, brand to act as proxy features for the model\n",
    "coupon_item_mapping['item_id_str']=coupon_item_mapping['item_id'].apply(str)\n",
    "prep_for_embeddings_items=coupon_item_mapping.groupby('coupon_id')['item_id_str'].unique().reset_index()\n",
    "main_item=[]\n",
    "for i in prep_for_embeddings_items['item_id_str']:\n",
    "    main_item.append(list(i))\n",
    "model_item=gensim.models.Word2Vec(main_item,size=20,window=5,min_count=1,workers=10)\n",
    "embeddings_items={}\n",
    "for i in list(model_item.wv.vocab):\n",
    "    embeddings_items[i]=model_item.wv[i]\n",
    "pickle.dump(embeddings_items,open('embedding_item','wb'),protocol=4)\n",
    "embeddings_items=pickle.load(open('embedding_item','rb'))\n",
    "coupon_item_data['brand_str']=coupon_item_data['brand'].apply(str)\n",
    "prep_for_embeddings_brands=coupon_item_data.groupby('coupon_id')['brand_str'].unique().reset_index()\n",
    "main_brand=[]\n",
    "for i in prep_for_embeddings_brands['brand_str']:\n",
    "    main_brand.append(list(i))\n",
    "model_brand=gensim.models.Word2Vec(main_brand,size=20,window=5,min_count=1,workers=10)\n",
    "embeddings_brand={}\n",
    "for i in list(model_brand.wv.vocab):\n",
    "    embeddings_brand[i]=model_brand.wv[i]\n",
    "pickle.dump(embeddings_brand,open('embedding_brand','wb'),protocol=4)\n",
    "embeddings_brand=pickle.load(open('embedding_brand','rb'))\n",
    "fin_item=[]\n",
    "for i in main_item:\n",
    "    fin_vect_item=[]\n",
    "    for j in i:\n",
    "        vect_item=embeddings_items[j]\n",
    "        fin_vect_item.append(vect_item)\n",
    "    fin_item.append(list(np.mean(fin_vect_item,axis=0)))\n",
    "embeds_item=pd.DataFrame(fin_item)\n",
    "embeds_item.columns=['item_'+str(i) for i in range(1,21)]\n",
    "fin_brand=[]\n",
    "for i in main_brand:\n",
    "    fin_vect_brand=[]\n",
    "    for j in i:\n",
    "        vect_brand=embeddings_brand[j]\n",
    "        fin_vect_brand.append(vect_brand)\n",
    "    fin_brand.append(list(np.mean(fin_vect_brand,axis=0)))\n",
    "embeds_brand=pd.DataFrame(fin_brand)\n",
    "embeds_brand.columns=['brand_'+str(i) for i in range(1,21)]\n",
    "embeds_brand['coupon_id']=prep_for_embeddings_brands['coupon_id']\n",
    "embeds_item['coupon_id']=prep_for_embeddings_items['coupon_id']\n",
    "embeds_brand.to_csv('embeds_brand.csv',index=False)\n",
    "embeds_item.to_csv('embeds_item.csv',index=False)\n",
    "embeds_brand=pd.read_csv('embeds_brand.csv')\n",
    "embeds_item=pd.read_csv('embeds_item.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ratio of moving target encoding of coupon by overall target encoding of coupon\n",
    "df_target['rat']=df_target['encoding_coupon']/df_target['encoding']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Merge training set with prepared embeddings\n",
    "df_target=df_target.merge(embeds_brand,on='coupon_id',how='left')\n",
    "df_target=df_target.merge(embeds_item,on='coupon_id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Merge with features from coupon item mapping\n",
    "df_target=df_target.merge(unique_item_data,on='coupon_id',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Add moving features from past campaigns related to customer's past actions on coupons, actions on coupons at coupon level\n",
    "df_fin=pd.DataFrame()\n",
    "for i in df_target['start_date'].unique():\n",
    "    chunk=df_target[df_target.start_date==i]\n",
    "    chunk=chunk.reset_index()\n",
    "    cp=df_target[df_target['start_date']<i]\n",
    "    cp=cp.reset_index()\n",
    "    cp=cp[cp.start_date==cp['start_date'].max()]\n",
    "    cp=cp.groupby('customer_id')['redemption_status'].sum().reset_index()\n",
    "    cp.columns=['customer_id','past_action']\n",
    "    chunk=(chunk.merge(cp,on='customer_id',how='left'))\n",
    "    df_fin=pd.concat([df_fin,chunk])\n",
    "df_fin['past_action']=df_fin['past_action'].fillna(0)\n",
    "df_finn=pd.DataFrame()\n",
    "for i in df_fin['start_date'].unique():\n",
    "    chunk=df_fin[df_fin.start_date==i]\n",
    "    chunk=chunk.reset_index()\n",
    "    cp=df_fin[df_fin['start_date']<i]\n",
    "    cp=cp.reset_index()\n",
    "    cp=cp[cp.start_date==cp['start_date'].max()]\n",
    "    cp=cp.groupby('coupon_id')['redemption_status'].sum().reset_index()\n",
    "    cp.columns=['coupon_id','past_action_cp']\n",
    "    chunk=(chunk.merge(cp,on='coupon_id',how='left'))\n",
    "    df_finn=pd.concat([df_finn,chunk])\n",
    "df_finn['past_action_cp']=df_finn['past_action_cp'].fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Get start and end dates of campaigns for some feaure engineering\n",
    "dates=pd.DataFrame()\n",
    "dates['start_date']=df_finn['start_date'].unique()\n",
    "dates['end_date']=df_finn['end_date'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Item level historic feature\n",
    "## Calculate match rate between items in a coupon and the all iterms bought before that coupon campaign combination\n",
    "dlist=[]\n",
    "clist=[]\n",
    "ilist=[]\n",
    "for i in range(dates.shape[0]):\n",
    "    print(i)\n",
    "#     print(dates['start_date'][i])\n",
    "    l1=df_finn[df_finn.start_date==dates['start_date'][i]]\n",
    "    l2=customer_transaction_data\n",
    "    l3=l2[(l2.date>=dates['start_date'][i]) & (l2.date<=dates['end_date'][i])]\n",
    "    l4=l2[l2.date<dates['start_date'][i]]\n",
    "    group=(l4.groupby('customer_id')['item_id'].unique().reset_index())\n",
    "    group['item_id']=[list(h) for h in group['item_id']]\n",
    "    dd={}\n",
    "    for p in range(group.shape[0]):\n",
    "        dd[group['customer_id'][p]]=group['item_id'][p]\n",
    "    uniq_customers=l3['customer_id'].unique()\n",
    "    for j in uniq_customers:\n",
    "#         print(j)\n",
    "        try:\n",
    "            l_cust=l3[l3.customer_id==j]\n",
    "            gr=dd[j]\n",
    "            ctr=0\n",
    "            for w in l_cust['item_id'].unique():\n",
    "                if w in (dd[j]):\n",
    "                    ctr=ctr+1\n",
    "                    dlist.append(dates['start_date'][i])\n",
    "#                     print(dates['start_date'][i])\n",
    "                    ilist.append(w)\n",
    "                    clist.append(j)\n",
    "#                     print(j)\n",
    "#                     print(w)\n",
    "#                     print(1)\n",
    "#             print(ctr)\n",
    "        except:\n",
    "            pass\n",
    "item_level=pd.DataFrame()\n",
    "item_level['customer_id']=clist\n",
    "item_level['item_id']=ilist\n",
    "item_level['start_date']=dlist\n",
    "item_level.to_csv('item_level.csv',index=False)\n",
    "item_level=pd.read_csv('item_level.csv')\n",
    "item_level['start_date']=pd.to_datetime(item_level['start_date'])\n",
    "it_level=item_level.groupby(['customer_id','start_date'])['item_id'].count().reset_index()\n",
    "it_level.columns=['customer_id','start_date','no_of_previous_clicks']\n",
    "df_finn=df_finn.merge(it_level,on=['customer_id','start_date'],how='left')\n",
    "list_items=item_level.groupby(['customer_id','start_date'])['item_id'].unique().reset_index()\n",
    "list_items.columns=['customer_id','start_date','all_items']\n",
    "list_items['all_items']=[list(h) for h in list_items['all_items']]\n",
    "df_finn=df_finn.merge(list_items,on=['customer_id','start_date'],how='left')\n",
    "cp_item=coupon_item_data.groupby('coupon_id')['item_id'].unique().reset_index()\n",
    "cp_item.columns=['coupon_id','all_items_cp']\n",
    "cp_item['all_items_cp']=[list(h) for h in cp_item['all_items_cp']]\n",
    "df_finn=df_finn.merge(cp_item,on=['coupon_id'],how='left')\n",
    "match=[]\n",
    "for i in range(df_finn.shape[0]):\n",
    "    try:\n",
    "        list1=df_finn['all_items'][i]\n",
    "        list2=df_finn['all_items_cp'][i]\n",
    "        val=len((list(set(list1).intersection(list2))))\n",
    "        match.append(val)\n",
    "    except:\n",
    "        match.append(0)\n",
    "        pass\n",
    "df_finn['match']=match\n",
    "df_finn['match_rate']=df_finn['match']/df_finn['no_of_previous_clicks']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Final features\n",
    "cols=['campaign_type','age_range',\n",
    "       'marital_status', 'rented', 'family_size', 'no_of_children',\n",
    "       'income_bracket', 'uniq_item_count', 'item_count', 'disc_count',\n",
    "       'disc_count_other', 'min_price', 'max_price', 'mean_price', 'sum',\n",
    "       'min_disc', 'max_disc', 'mean_disc', 'sum_disc', 'min_rat', 'max_rat',\n",
    "       'mean_rat', 'total_item_count','encoding_coupon','rat','item_id_uniq',\n",
    "       'brand_uniq', 'brand_type_uniq','past_action','no_of_users','uniq_brand_count','no_of_previous_clicks','match','match_rate','brand_1', 'brand_2','brand_3', 'brand_4', 'brand_5', 'item_1', 'item_2', 'item_3', 'item_4', 'item_5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Group Kfold on campaigns for stable cross validation, even timeseries split worked well for this competition with cv and lb in good sync\n",
    "groups=df_finn[['campaign_id']].drop_duplicates()\n",
    "groups['groups']=[i for i in range(groups.shape[0])]\n",
    "df_finn=df_finn.merge(groups,on=['campaign_id'],how='left')\n",
    "gkf=GroupKFold(n_splits=5)\n",
    "f=gkf.split(df_finn,df_finn['redemption_status'],groups=df_finn[['groups']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/lightgbm/basic.py:1205: UserWarning: Using categorical_feature in Dataset.\n",
      "  warnings.warn('Using categorical_feature in Dataset.')\n",
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/lightgbm/basic.py:741: UserWarning: silent keyword has been found in `params` and will be ignored.\n",
      "Please use silent argument of the Dataset constructor to pass this parameter.\n",
      "  .format(key))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10]\tcv_agg's auc: 0.89415 + 0.0241148\n",
      "[20]\tcv_agg's auc: 0.900606 + 0.0221503\n",
      "[30]\tcv_agg's auc: 0.907134 + 0.0215019\n",
      "[40]\tcv_agg's auc: 0.909191 + 0.0210637\n",
      "[50]\tcv_agg's auc: 0.92071 + 0.0186518\n",
      "[60]\tcv_agg's auc: 0.923375 + 0.0174722\n",
      "[70]\tcv_agg's auc: 0.925914 + 0.0157293\n",
      "[80]\tcv_agg's auc: 0.930748 + 0.0127914\n",
      "[90]\tcv_agg's auc: 0.933011 + 0.0117318\n",
      "[100]\tcv_agg's auc: 0.932968 + 0.0112989\n",
      "[110]\tcv_agg's auc: 0.933075 + 0.0100201\n",
      "[120]\tcv_agg's auc: 0.93443 + 0.00867283\n",
      "[130]\tcv_agg's auc: 0.935497 + 0.00828952\n",
      "[140]\tcv_agg's auc: 0.936122 + 0.00872145\n",
      "[150]\tcv_agg's auc: 0.93591 + 0.0088118\n",
      "[160]\tcv_agg's auc: 0.936328 + 0.00852721\n",
      "[170]\tcv_agg's auc: 0.937275 + 0.00826371\n",
      "[180]\tcv_agg's auc: 0.93741 + 0.00771267\n",
      "[190]\tcv_agg's auc: 0.937071 + 0.00801193\n",
      "[200]\tcv_agg's auc: 0.93779 + 0.00822151\n",
      "[210]\tcv_agg's auc: 0.937955 + 0.00842779\n",
      "[220]\tcv_agg's auc: 0.937574 + 0.00825127\n",
      "[230]\tcv_agg's auc: 0.937734 + 0.00844918\n",
      "[240]\tcv_agg's auc: 0.937648 + 0.00825732\n",
      "[250]\tcv_agg's auc: 0.937278 + 0.00875423\n",
      "[260]\tcv_agg's auc: 0.937039 + 0.00869809\n",
      "[270]\tcv_agg's auc: 0.937648 + 0.00847469\n",
      "[280]\tcv_agg's auc: 0.937374 + 0.0087366\n",
      "[290]\tcv_agg's auc: 0.937294 + 0.00903344\n",
      "[300]\tcv_agg's auc: 0.937343 + 0.0089937\n",
      "[310]\tcv_agg's auc: 0.937563 + 0.00864027\n",
      "[320]\tcv_agg's auc: 0.937733 + 0.00905346\n",
      "[330]\tcv_agg's auc: 0.937408 + 0.00907787\n",
      "[340]\tcv_agg's auc: 0.936945 + 0.00931364\n",
      "[350]\tcv_agg's auc: 0.936556 + 0.00901763\n",
      "[360]\tcv_agg's auc: 0.936542 + 0.00919234\n",
      "[370]\tcv_agg's auc: 0.936346 + 0.00936282\n",
      "[380]\tcv_agg's auc: 0.935615 + 0.00955633\n",
      "[390]\tcv_agg's auc: 0.935268 + 0.00942932\n",
      "[400]\tcv_agg's auc: 0.934842 + 0.00978959\n",
      "[410]\tcv_agg's auc: 0.934387 + 0.00975309\n",
      "[420]\tcv_agg's auc: 0.934438 + 0.00960399\n",
      "[430]\tcv_agg's auc: 0.933719 + 0.00953082\n",
      "[440]\tcv_agg's auc: 0.933665 + 0.00939883\n",
      "[450]\tcv_agg's auc: 0.933847 + 0.00942623\n",
      "[460]\tcv_agg's auc: 0.933384 + 0.00999368\n",
      "[470]\tcv_agg's auc: 0.933483 + 0.009859\n",
      "[480]\tcv_agg's auc: 0.933255 + 0.00968782\n",
      "[490]\tcv_agg's auc: 0.933634 + 0.00962599\n",
      "[500]\tcv_agg's auc: 0.932982 + 0.0101311\n",
      "[510]\tcv_agg's auc: 0.932895 + 0.0102818\n",
      "[520]\tcv_agg's auc: 0.932671 + 0.010405\n",
      "[530]\tcv_agg's auc: 0.932938 + 0.0102403\n",
      "[540]\tcv_agg's auc: 0.932927 + 0.0103886\n",
      "[550]\tcv_agg's auc: 0.932753 + 0.0104474\n",
      "[560]\tcv_agg's auc: 0.932546 + 0.0105721\n",
      "[570]\tcv_agg's auc: 0.932671 + 0.0106618\n",
      "[580]\tcv_agg's auc: 0.932897 + 0.0107479\n",
      "[590]\tcv_agg's auc: 0.932748 + 0.0107001\n",
      "[600]\tcv_agg's auc: 0.933003 + 0.0106441\n",
      "[610]\tcv_agg's auc: 0.932245 + 0.010749\n",
      "[620]\tcv_agg's auc: 0.931986 + 0.0107305\n",
      "[630]\tcv_agg's auc: 0.931582 + 0.0108031\n",
      "[640]\tcv_agg's auc: 0.931607 + 0.0106761\n",
      "[650]\tcv_agg's auc: 0.93152 + 0.0106899\n",
      "[660]\tcv_agg's auc: 0.931327 + 0.0107489\n",
      "[670]\tcv_agg's auc: 0.931152 + 0.0108325\n",
      "[680]\tcv_agg's auc: 0.931074 + 0.0107954\n",
      "[690]\tcv_agg's auc: 0.931109 + 0.0106196\n",
      "[700]\tcv_agg's auc: 0.930784 + 0.0108579\n",
      "[710]\tcv_agg's auc: 0.930486 + 0.0107855\n",
      "[720]\tcv_agg's auc: 0.930547 + 0.0106438\n",
      "[730]\tcv_agg's auc: 0.930334 + 0.010647\n",
      "[740]\tcv_agg's auc: 0.930184 + 0.0106155\n",
      "[750]\tcv_agg's auc: 0.930069 + 0.0103903\n",
      "[760]\tcv_agg's auc: 0.930186 + 0.0103598\n",
      "[770]\tcv_agg's auc: 0.930399 + 0.0104584\n",
      "[780]\tcv_agg's auc: 0.929916 + 0.0108578\n",
      "[790]\tcv_agg's auc: 0.929752 + 0.0108679\n",
      "[800]\tcv_agg's auc: 0.929643 + 0.011097\n",
      "[810]\tcv_agg's auc: 0.92934 + 0.0114273\n"
     ]
    }
   ],
   "source": [
    "## Cross Validation\n",
    "# params={'silent': 1, 'verbose_eval': True, 'objective': 'binary', 'device': 'cpu', 'boosting': 'gbdt', 'metric': 'auc', 'boost_from_average': False,'is_unbalance':False}\n",
    "params={'min_sum_hessian_in_leaf': 10, 'min_data_in_leaf': 209, 'num_leaves': 56, 'subsample': 0.9836720837731385, 'colsample_bytree': 0.5572015972699615, 'learning_rate': 0.11758858551341646, 'silent': 1, 'verbose_eval': True, 'objective': 'binary', 'device': 'cpu', 'boosting': 'gbdt', 'max_depth': 2, 'bagging_freq': 5, 'metric': 'auc', 'boost_from_average': False}\n",
    "lgtrain = lgb.Dataset(df_finn[cols], label=df_finn['redemption_status'],categorical_feature=['campaign_type','marital_status'])\n",
    "cv = lgb.cv(params,\n",
    "                lgtrain,metrics='auc',\n",
    "                num_boost_round=15000,\n",
    "                early_stopping_rounds=600,verbose_eval=10,folds=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.008365384819883567"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv['auc-stdv'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9379825210611603"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv['auc-mean'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "211"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(cv['auc-mean'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/lightgbm/basic.py:1205: UserWarning: Using categorical_feature in Dataset.\n",
      "  warnings.warn('Using categorical_feature in Dataset.')\n",
      "/home/Mahir/anaconda3/lib/python3.7/site-packages/lightgbm/basic.py:741: UserWarning: silent keyword has been found in `params` and will be ignored.\n",
      "Please use silent argument of the Dataset constructor to pass this parameter.\n",
      "  .format(key))\n"
     ]
    }
   ],
   "source": [
    "## Final Model\n",
    "params={'silent': 1, 'verbose_eval': True, 'objective': 'binary', 'device': 'cpu', 'boosting': 'gbdt', 'metric': 'auc', 'boost_from_average': False,'is_unbalance':False}\n",
    "params={'min_sum_hessian_in_leaf': 10, 'min_data_in_leaf': 209, 'num_leaves': 56, 'subsample': 0.9836720837731385, 'colsample_bytree': 0.5572015972699615, 'learning_rate': 0.11758858551341646, 'silent': 1, 'verbose_eval': True, 'objective': 'binary', 'device': 'cpu', 'boosting': 'gbdt', 'max_depth': 2, 'bagging_freq': 5, 'metric': 'auc', 'boost_from_average': False}\n",
    "lgtrain = lgb.Dataset(df_finn[cols], label=df_finn['redemption_status'],categorical_feature=['campaign_type','marital_status'])\n",
    "model = lgb.train(params,\n",
    "                lgtrain,\n",
    "                num_boost_round=len(cv['auc-mean']),verbose_eval=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "211"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.num_trees()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcd8c3b43c8>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "lgb.plot_importance(model,importance_type='gain')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Make all features for test\n",
    "relevant_transactions['ratio']=abs(relevant_transactions['coupon_discount']/relevant_transactions['selling_price'])\n",
    "customer_uniq_item_count=relevant_transactions.groupby(['customer_id'])['item_id'].nunique().reset_index()\n",
    "customer_uniq_item_count.columns=['customer_id','uniq_item_count']\n",
    "customer_item_count=relevant_transactions.groupby(['customer_id'])['item_id'].count().reset_index()\n",
    "customer_item_count.columns=['customer_id','item_count']\n",
    "customer_total_item_count=relevant_transactions.groupby('customer_id')['quantity'].sum().reset_index()\n",
    "customer_total_item_count.columns=['customer_id','total_item_count']\n",
    "discounts_count_coupon=relevant_transactions[relevant_transactions['coupon_discount']<0].groupby('customer_id')['coupon_discount'].count().reset_index()\n",
    "discounts_count_coupon.columns=['customer_id','disc_count']\n",
    "discounts_count_other=relevant_transactions[relevant_transactions['other_discount']<0].groupby('customer_id')['other_discount'].count().reset_index()\n",
    "discounts_count_other.columns=['customer_id','disc_count_other']\n",
    "cust_price=relevant_transactions.groupby(['customer_id'])['selling_price'].agg(['min','max','mean','sum']).reset_index()\n",
    "cust_price.columns=['customer_id','min_price','max_price','mean_price','sum']\n",
    "discounts_feats_coupon=relevant_transactions[relevant_transactions['coupon_discount']<0].groupby('customer_id')['coupon_discount'].agg(['min','max','mean','sum']).reset_index()\n",
    "discounts_feats_coupon.columns=['customer_id','min_disc','max_disc','mean_disc','sum_disc']\n",
    "mean_disc_to_price=relevant_transactions[relevant_transactions['coupon_discount']<0].groupby('customer_id')['ratio'].agg(['min','max','mean']).reset_index()\n",
    "mean_disc_to_price.columns=['customer_id','min_rat','max_rat','mean_rat']\n",
    "test_main=test_demo.merge(customer_uniq_item_count,on='customer_id',how='left')\n",
    "test_main=test_main.merge(customer_item_count,on='customer_id',how='left')\n",
    "test_main=test_main.merge(discounts_count_coupon,on='customer_id',how='left')\n",
    "test_main=test_main.merge(discounts_count_other,on='customer_id',how='left')\n",
    "test_main=test_main.merge(cust_price,on='customer_id',how='left')\n",
    "test_main=test_main.merge(discounts_feats_coupon,on='customer_id',how='left')\n",
    "test_main=test_main.merge(mean_disc_to_price,on='customer_id',how='left')\n",
    "test_main=test_main.merge(customer_total_item_count,on='customer_id',how='left')\n",
    "test_main['min_disc']=abs(test_main['min_disc'])\n",
    "test_main['max_disc']=abs(test_main['max_disc'])\n",
    "test_main['mean_disc']=abs(test_main['mean_disc'])\n",
    "test_main['sum_disc']=abs(test_main['sum_disc'])\n",
    "target_enc_test = df_target.groupby(by = ['coupon_id'])['redemption_status'].agg(['sum','count']).reset_index()\n",
    "target_enc_test.columns = ['coupon_id',\"target_sum\",\"target_count\"]\n",
    "target_enc_test['encoding_coupon'] = target_enc_test.target_sum/target_enc_test.target_count\n",
    "test_main=test_main.merge(target_enc_test,on='coupon_id',how='left')\n",
    "test_main=test_main.merge(embeds_brand,on='coupon_id',how='left')\n",
    "test_main=test_main.merge(embeds_item,on='coupon_id',how='left')\n",
    "test_main=test_main.merge(unique_item_data,on='coupon_id',how='left')\n",
    "test_main=test_main.merge(cp,on='coupon_id',how='left')\n",
    "test_main=test_main.merge(target_enc1,on='coupon_id',how='left')\n",
    "test_main['rat']=test_main['encoding_coupon']/test_main['encoding']\n",
    "people_coupons1=df_fin[df_fin['redemption_status']==1].groupby('coupon_id')['customer_id'].nunique().reset_index()\n",
    "people_coupons1.columns=['coupon_id','no_of_users']\n",
    "test_main=test_main.merge(people_coupons1,on='coupon_id',how='left')\n",
    "cpt=df_fin.groupby('customer_id')['redemption_status'].sum().reset_index()\n",
    "cpt.columns=['customer_id','past_action']\n",
    "test_main=(test_main.merge(cpt,on='customer_id',how='left'))\n",
    "uniq_brands_t=relevant_transactions.groupby(['customer_id'])['brand'].nunique().reset_index()\n",
    "uniq_brands_t.columns=['customer_id','uniq_brand_count']\n",
    "test_main=(test_main.merge(uniq_brands_t,on='customer_id',how='left'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "it_level_t=customer_transaction_data.groupby(['customer_id'])['item_id'].nunique().reset_index()\n",
    "it_level_t.columns=['customer_id','no_of_previous_clicks']\n",
    "test_main=test_main.merge(it_level_t,on=['customer_id'],how='left')\n",
    "list_items1=customer_transaction_data.groupby(['customer_id'])['item_id'].unique().reset_index()\n",
    "list_items1.columns=['customer_id','all_items']\n",
    "list_items1['all_items']=[list(h) for h in list_items1['all_items']]\n",
    "test_main=test_main.merge(list_items1,on=['customer_id'],how='left')\n",
    "cp_item1=coupon_item_data.groupby('coupon_id')['item_id'].unique().reset_index()\n",
    "cp_item1.columns=['coupon_id','all_items_cp']\n",
    "cp_item1['all_items_cp']=[list(h) for h in cp_item1['all_items_cp']]\n",
    "test_main=test_main.merge(cp_item1,on=['coupon_id'],how='left')\n",
    "match1=[]\n",
    "for i in range(test_main.shape[0]):\n",
    "    try:\n",
    "        list11=test_main['all_items'][i]\n",
    "        list21=test_main['all_items_cp'][i]\n",
    "        val1=len((list(set(list11).intersection(list21))))\n",
    "        match1.append(val1)\n",
    "    except:\n",
    "        match1.append(0)\n",
    "        pass\n",
    "test_main['match']=match1\n",
    "test_main['match_rate']=test_main['match']/test_main['no_of_previous_clicks']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "op=pd.DataFrame()\n",
    "op['id']=test_main['id']\n",
    "op['redemption_status']=model.predict(test_main[cols])\n",
    "op.to_csv('op.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Hyperparameter tuning\n",
    "# param_dict={}\n",
    "# space = {'max_depth': hp.choice('max_depth', np.arange(-1, 20,dtype=int)),\n",
    "#          'min_data_in_leaf': hp.choice('min_data_in_leaf', np.arange(10, 400,dtype=int)),\n",
    "#          'min_sum_hessian_in_leaf': hp.choice('min_sum_hessian_in_leaf', np.arange(0, 15,dtype=int)),\n",
    "#          'num_leaves': hp.choice('num_leaves', np.arange(2, 200, dtype=int)),\n",
    "#          'bagging_freq': hp.choice('bagging_freq', np.arange(1, 20, dtype=int)),\n",
    "#          'subsample': hp.uniform('subsample', 0, 1),\n",
    "#          'colsample_bytree': hp.uniform('colsample_bytree', 0, 1),\n",
    "#         'learning_rate': hp.uniform('learning_rate', 0.08, 0.2),\n",
    "#         }\n",
    "\n",
    "\n",
    "# def objective(space):\n",
    "#     params = {\n",
    "#         'min_sum_hessian_in_leaf': space['min_sum_hessian_in_leaf'],\n",
    "#         'min_data_in_leaf':space['min_data_in_leaf'],\n",
    "#             'num_leaves':space['num_leaves'],\n",
    "#              'subsample': space['subsample'],\n",
    "#             'colsample_bytree': space['colsample_bytree'],\n",
    "#             'learning_rate':space['learning_rate'],\n",
    "#             'silent': 1,\n",
    "#             'verbose_eval': True,\n",
    "#             \"objective\":\"binary\",\n",
    "#         'device':'cpu',\n",
    "#         \"boosting\":\"gbdt\",\n",
    "#         'max_depth':space['max_depth'],\n",
    "#         'bagging_freq':space['bagging_freq'],\n",
    "#           'metric':\"auc\",\n",
    "#     'boost_from_average':False,\n",
    "#     }\n",
    "#     lgtrain = lgb.Dataset(df_finn[cols], label=df_finn['redemption_status'],categorical_feature=['campaign_type','marital_status'])\n",
    "#     cv = lgb.cv(params,\n",
    "#                 lgtrain,metrics='auc',\n",
    "#                 num_boost_round=15000,\n",
    "#                 early_stopping_rounds=600,verbose_eval=500,folds=f)\n",
    "#     au = (cv['auc-mean'][-1])\n",
    "#     params['n_estimators']=len(cv['auc-mean'])\n",
    "#     param_dict[au]=params\n",
    "#     pickle.dump(param_dict,open('params','wb'))\n",
    "#     print(params, file=open(\"output_lgb.txt\", \"a\"))\n",
    "#     print(params)\n",
    "#     print('max='+str(max(param_dict.keys())))\n",
    "#     print ('auc = ', au)\n",
    "#     print(au, file=open(\"output_lgb.txt\", \"a\"))\n",
    "#     return{'loss': -au, 'status': STATUS_OK}\n",
    "\n",
    "\n",
    "# trials = Trials()\n",
    "# best = hyperopt.fmin(fn=objective,\n",
    "#             space=space,\n",
    "#             algo=tpe.suggest,\n",
    "#             max_evals=10000,\n",
    "#             trials=trials\n",
    "#             )\n",
    "\n",
    "# print(best)\n",
    "\n",
    "# fName = open('trials.pkl', 'w')\n",
    "# pickle.dump(trials, fName)\n",
    "# fName.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}