competition_notebooks/kaggle/malware/rapids_solution_gpu_only.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "GPU_id = 0\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = str(GPU_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cudf as gd\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import time\n",
    "from collections import OrderedDict,Counter\n",
    "from nvstring_workaround import on_gpu\n",
    "from sklearn.model_selection import KFold\n",
    "import xgboost as xgb\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This notebook contains a rapids solution to achieve 0.695 private LB in 12 minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rm_cols(gdf,cols):\n",
    "    gcols = [i for i in gdf.columns]\n",
    "    for col in cols:\n",
    "        if col in gcols:\n",
    "            gdf.drop_column(col)\n",
    "    return gdf\n",
    "\n",
    "def reset_col_dtype(gtr,gte):\n",
    "    for col in gtr.columns:\n",
    "        a,b = str(gtr[col].dtype),str(gte[col].dtype)\n",
    "        if a!=b:\n",
    "            gtr[col] = gtr[col].astype('float32')\n",
    "            gte[col] = gte[col].astype('float32')\n",
    "    return gtr,gte\n",
    "\n",
    "def count_encode(df,cols):\n",
    "    df['idx'] = np.arange(len(df))\n",
    "    for col in cols:\n",
    "        df[col] = df[col].fillna(-999)\n",
    "        dg = df.groupby(col).agg({col:'count'})\n",
    "        dg.columns = ['count_%s'%col]\n",
    "        dg = dg.reset_index()\n",
    "        df = df.merge(dg,on=[col],how='left')\n",
    "        df.drop_column(col)\n",
    "    df = df.sort_values(by='idx')\n",
    "    df.drop_column('idx')\n",
    "    df = rm_cols(df,[i for i in df.columns if i.startswith('count_')==0])\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mtr(tr,col,te):\n",
    "    tr[col] = tr[col].fillna(-999)\n",
    "    tr[YCOL] = tr[YCOL].astype('float32')\n",
    "    dg = tr.groupby(col).agg({YCOL:'mean'})\n",
    "    dg.columns = ['mtr_%s'%col]\n",
    "    dg = dg.reset_index()\n",
    "    te = te.merge(dg,on=[col],how='left')\n",
    "    del dg\n",
    "    return te\n",
    "\n",
    "def mtr_encode(tr,te,cols):\n",
    "    tr['idx'] = np.arange(len(tr))\n",
    "    tr['random'] = np.random.random(len(tr))\n",
    "    tr = tr.sort_values(by='random')\n",
    "    tr.drop_column('random')\n",
    "    N = len(tr)//2\n",
    "    tr1 = tr[:N]\n",
    "    tr2 = tr[N:]\n",
    "    te['idx'] = np.arange(len(te))\n",
    "    for col in cols:\n",
    "        if col not in tr.columns:\n",
    "            continue\n",
    "        tr2 = mtr(tr1,col,tr2)\n",
    "        tr1 = mtr(tr2,col,tr1)\n",
    "        te = mtr(tr,col,te)\n",
    "    if len(tr1.columns)!=len(tr2.columns):\n",
    "        del tr1,tr2\n",
    "        return rm_cols(tr,[i for i in tr.columns]),rm_cols(te,[i for i in te.columns])\n",
    "    del tr\n",
    "    tr = gd.concat([tr1,tr2])\n",
    "    tr = tr.sort_values(by='idx')\n",
    "    tr = rm_cols(tr,[i for i in tr.columns if i.startswith('mtr_')==0])\n",
    "    del tr1,tr2\n",
    "    te = te.sort_values(by='idx')\n",
    "    te = rm_cols(te,[i for i in te.columns if i.startswith('mtr_')==0])\n",
    "    return tr,te"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "timing_gpu={}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 7.39 s, sys: 2.94 s, total: 10.3 s\n",
      "Wall time: 10.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"read data\"\n",
    "\n",
    "IDCOL = 'MachineIdentifier'\n",
    "YCOL = 'HasDetections'\n",
    "PATH = '.'\n",
    "tr_path = '%s/train.csv'%PATH\n",
    "te_path = '%s/test.csv'%PATH\n",
    "gtr = gd.read_csv(tr_path)\n",
    "gte = gd.read_csv(te_path)\n",
    "\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "for col in gtr.columns:\n",
    "    if gtr[col].dtype=='object':\n",
    "        gtr[col] = gtr[col].hash_values()\n",
    "for col in gte.columns:\n",
    "    if gte[col].dtype=='object':\n",
    "        gte[col] = gte[col].hash_values()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.74 s, sys: 1.58 s, total: 8.31 s\n",
      "Wall time: 2.68 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"count encode\"\n",
    "\n",
    "count_cols = ['CityIdentifier', 'Census_OSBuildRevision', 'Census_TotalPhysicalRAM']\n",
    "N = len(gtr)\n",
    "gtr1,gte1 = gtr[count_cols],gte[count_cols]\n",
    "gtr1,gte1 = reset_col_dtype(gtr1,gte1)\n",
    "df = gd.concat([gtr1,gte1])\n",
    "del gtr1,gte1\n",
    "\n",
    "df = count_encode(df,count_cols)\n",
    "data = df.to_pandas().values\n",
    "count_tr,count_te = data[:N],data[N:]\n",
    "count_cols = ['count_%s'%i for i in count_cols]\n",
    "\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.54 s, sys: 688 ms, total: 5.22 s\n",
      "Wall time: 1.85 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"target encode\"\n",
    "\n",
    "mtr_cols = ['SmartScreen']\n",
    "gtr1 = gtr[mtr_cols+[YCOL]] \n",
    "gte1 = gte[mtr_cols]\n",
    "\n",
    "gtr1,gte1 = mtr_encode(gtr1,gte1,mtr_cols)\n",
    "mtr_tr,mtr_te = gtr1.to_pandas(),gte1.to_pandas()\n",
    "mtr_cols = [i for i in mtr_tr.columns]\n",
    "mtr_tr,mtr_te = mtr_tr.values,mtr_te.values\n",
    "del gtr1,gte1\n",
    "\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### target encode will be much faster if the column has many levels. Unfortunately 'SmartScreen' only has several levels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### remove columns & combine all features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8921483, 81) (7853253, 81)\n",
      "CPU times: user 5min 46s, sys: 2min 24s, total: 8min 10s\n",
      "Wall time: 15.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"combine\"\n",
    "\n",
    "badcols = ['PuaMode','OsSuite','ProductName','SmartScreen']\n",
    "y = gtr[YCOL].to_pandas().values\n",
    "\n",
    "gtr = rm_cols(gtr,[IDCOL,YCOL]+badcols)\n",
    "gte = rm_cols(gte,[IDCOL,YCOL]+badcols)\n",
    "\n",
    "tr = gtr.to_pandas()\n",
    "te = gte.to_pandas()\n",
    "\n",
    "cols = [i for i in tr.columns]\n",
    "tr,te = tr.values,te.values\n",
    "\n",
    "train = np.hstack([tr,count_tr,mtr_tr])\n",
    "test = np.hstack([te,count_te,mtr_te])\n",
    "cols = cols + count_cols + mtr_cols\n",
    "\n",
    "print(train.shape, test.shape)\n",
    "#print(cols)\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb_params =  {\n",
    "        'objective': 'binary:logistic',\n",
    "        'tree_method': 'hist',\n",
    "        'eta':0.1,\n",
    "        'nthread': 16,\n",
    "        'max_depth': 10,\n",
    "        'silent':1,\n",
    "        'subsample':0.8,\n",
    "        'colsample_bytree': 0.7,\n",
    "        'min_child_weight':10,\n",
    "        'eval_metric':'auc',\n",
    "}\n",
    "\n",
    "xgb_gpu_params = xgb_params.copy()\n",
    "xgb_gpu_params.update({'tree_method': 'gpu_hist',})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train & Predict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fold 0 done\n",
      "fold 1 done\n",
      "fold 2 done\n",
      "fold 3 done\n",
      "CPU times: user 6min 46s, sys: 3min 24s, total: 10min 10s\n",
      "Wall time: 10min 13s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"train & predict\"\n",
    "\n",
    "feature_names = cols\n",
    "pred = 0\n",
    "kf = KFold(n_splits=4, shuffle=True, random_state=42)\n",
    "for i,(train_index, test_index) in enumerate(kf.split(train)):\n",
    "    y_train,y_test = y[train_index],y[test_index]\n",
    "    X_train,X_test = train[train_index],train[test_index]\n",
    "    watchlist = ()\n",
    "    dtrain = xgb.DMatrix(data=X_train, label=y_train, feature_names=feature_names)\n",
    "    dtest = xgb.DMatrix(data=test, feature_names=feature_names)\n",
    "    clf = xgb.train(xgb_gpu_params, dtrain=dtrain,\n",
    "                num_boost_round=500,evals=watchlist,\n",
    "                early_stopping_rounds=None,maximize=True,\n",
    "                verbose_eval=100)\n",
    "    pred += clf.predict(dtest)\n",
    "    print('fold',i,'done')\n",
    "pred /= (i+1)\n",
    "\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sub = pd.read_csv('%s/sample_submission.csv'%PATH)\n",
    "#sub[YCOL] = pred\n",
    "#sub.to_csv('rapids_sub.csv.gz',index=False,compression='gzip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fc9c4590a20>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "steps = ['read data','count encode','target encode','combine','train & predict']\n",
    "GPU_RUN_TIME = timing_gpu\n",
    "GPU_RUN_TIME['Overall'] = sum([GPU_RUN_TIME[i] for i in steps])\n",
    "steps.append('Overall')\n",
    "gpu_time = [GPU_RUN_TIME[i] for i in steps]\n",
    "df = pd.DataFrame({'GPU': gpu_time}, index=steps)\n",
    "df.plot.bar(rot=0,figsize=(20,5), fontsize=15, title='Running time: seconds')"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}