competition_notebooks/kaggle/malware/rapids_solution_gpu_vs_cpu.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "GPU_id = 1\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\n",
    "\n",
    "def count_encode_cpu(df,cols):\n",
    "    for col in cols:\n",
    "        dg = df.groupby(col).agg({col:'count'})\n",
    "        dg.columns = ['count_%s'%col]\n",
    "        df = df.merge(dg.reset_index(),on=[col],how='left')\n",
    "    return df[[i for i in df.columns if i.startswith('count_')]]"
   ]
  },
  {
   "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": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mtr_cpu(tr,col,te):\n",
    "    dg = tr.groupby(col).agg({YCOL:'mean'})\n",
    "    dg.columns = ['mtr_%s'%col]\n",
    "    te = te.merge(dg.reset_index(),on=[col],how='left')\n",
    "    del dg\n",
    "    return te\n",
    "\n",
    "def mtr_encode_cpu(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('random',axis=1,inplace=True)\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_cpu(tr1,col,tr2)\n",
    "        tr1 = mtr_cpu(tr2,col,tr1)\n",
    "        te = mtr_cpu(tr,col,te)\n",
    "    del tr\n",
    "    tr = pd.concat([tr1,tr2],axis=0).reset_index(drop=True)\n",
    "    tr = tr.sort_values(by='idx')\n",
    "    cols = [i for i in tr.columns if i.startswith('mtr_')]\n",
    "    tr = tr[cols]\n",
    "    del tr1,tr2\n",
    "    te = te.sort_values(by='idx')\n",
    "    te = te[cols]\n",
    "    return tr,te"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read data & label encode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "timing_gpu={}\n",
    "timing_cpu={}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 10.1 s, sys: 5.04 s, total: 15.1 s\n",
      "Wall time: 15.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"read data & label encode\"\n",
    "\n",
    "IDCOL = 'MachineIdentifier'\n",
    "YCOL = 'HasDetections'\n",
    "\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",
    "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()   \n",
    "\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AppVersion done\n",
      "AvSigVersion done\n",
      "Census_ActivationChannel done\n",
      "Census_ChassisTypeName done\n",
      "Census_DeviceFamily done\n",
      "Census_FlightRing done\n",
      "Census_GenuineStateName done\n",
      "Census_InternalBatteryType done\n",
      "Census_MDC2FormFactor done\n",
      "Census_OSArchitecture done\n",
      "Census_OSBranch done\n",
      "Census_OSEdition done\n",
      "Census_OSInstallTypeName done\n",
      "Census_OSSkuName done\n",
      "Census_OSVersion done\n",
      "Census_OSWUAutoUpdateOptionsName done\n",
      "Census_PowerPlatformRoleName done\n",
      "Census_PrimaryDiskTypeName done\n",
      "Census_ProcessorClass done\n",
      "EngineVersion done\n",
      "OsBuildLab done\n",
      "OsPlatformSubRelease done\n",
      "OsVer done\n",
      "Platform done\n",
      "Processor done\n",
      "ProductName done\n",
      "PuaMode done\n",
      "SkuEdition done\n",
      "SmartScreen done\n",
      "CPU times: user 17min 52s, sys: 5min 32s, total: 23min 25s\n",
      "Wall time: 6min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "\n",
    "dtr = pd.read_csv(tr_path)\n",
    "dte = pd.read_csv(te_path)\n",
    "\n",
    "N = dtr.shape[0]\n",
    "df = pd.concat([dtr,dte],axis=0).reset_index(drop=True)\n",
    "\n",
    "for col in df.columns:\n",
    "    if col != IDCOL and df[col].dtype=='O':\n",
    "        df[col],_ = df[col].factorize()\n",
    "        print(col,'done')\n",
    "        \n",
    "dtr,dte = df.iloc[:N].reset_index(drop=True),df.iloc[N:].reset_index(drop=True)\n",
    "timing_cpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.13 s, sys: 972 ms, total: 7.1 s\n",
      "Wall time: 3.26 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",
    "del df\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": [
    "#### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 21s, sys: 8.28 s, total: 1min 29s\n",
      "Wall time: 12.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "\n",
    "cols = ['CityIdentifier', 'Census_OSBuildRevision', 'Census_TotalPhysicalRAM']\n",
    "N = len(gtr)\n",
    "N = len(dtr)\n",
    "dtr1,dte1 = dtr[cols],dte[cols]\n",
    "df = pd.concat([dtr1,dte1],axis=0)\n",
    "\n",
    "df = count_encode_cpu(df,cols)\n",
    "data = df.values\n",
    "count_tr_cpu,count_te_cpu = data[:N],data[N:]\n",
    "\n",
    "timing_cpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.57 s, sys: 824 ms, total: 7.39 s\n",
      "Wall time: 1.74 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": [
    "#### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 57s, sys: 9.13 s, total: 2min 6s\n",
      "Wall time: 10.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "\n",
    "cols = ['SmartScreen']\n",
    "dtr1 = dtr[cols+[YCOL]] \n",
    "dte1 = dte[cols]\n",
    "\n",
    "dtr1,dte1 = mtr_encode_cpu(dtr1,dte1,cols)\n",
    "mtr_tr_cpu,mtr_te_cpu = dtr1.values,dte1.values\n",
    "\n",
    "timing_cpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### target encode on gpu 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": "markdown",
   "metadata": {},
   "source": [
    "#### GPU "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8921483, 81) (7853253, 81)\n",
      "CPU times: user 3min 6s, sys: 1min 44s, total: 4min 50s\n",
      "Wall time: 10.2 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",
    "feature_names = cols + count_cols + mtr_cols\n",
    "\n",
    "print(train.shape, test.shape)\n",
    "#print(cols)\n",
    "timing_gpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8921483, 81) (7853253, 81)\n",
      "CPU times: user 40 s, sys: 49 s, total: 1min 28s\n",
      "Wall time: 17.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "\n",
    "badcols = ['PuaMode','OsSuite','ProductName','SmartScreen']\n",
    "usecols = [i for i in dtr.columns if i not in badcols+[IDCOL,YCOL]]\n",
    "dtr = dtr[usecols].values\n",
    "dte = dte[usecols].values\n",
    "\n",
    "train_cpu = np.hstack([dtr,count_tr_cpu,mtr_tr_cpu])\n",
    "test_cpu = np.hstack([dte,count_te_cpu,mtr_te_cpu])\n",
    "\n",
    "print(train_cpu.shape, test_cpu.shape)\n",
    "#print(cols)\n",
    "timing_cpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb_cpu_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_cpu_params.copy()\n",
    "xgb_gpu_params.update({'tree_method': 'gpu_hist',})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train & Predict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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 48s, sys: 3min 35s, total: 10min 24s\n",
      "Wall time: 10min 17s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "step = \"train & predict\"\n",
    "\n",
    "\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": [
    "#### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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 8h 11min 58s, sys: 22min 38s, total: 8h 34min 37s\n",
      "Wall time: 34min 15s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "start = time.time()\n",
    "\n",
    "pred_cpu = 0\n",
    "kf = KFold(n_splits=4, shuffle=True, random_state=42)\n",
    "for i,(train_index, test_index) in enumerate(kf.split(train_cpu)):\n",
    "    y_train,y_test = y[train_index],y[test_index]\n",
    "    X_train,X_test = train_cpu[train_index],train_cpu[test_index]\n",
    "    watchlist = ()\n",
    "    dtrain = xgb.DMatrix(data=X_train, label=y_train, feature_names=feature_names)\n",
    "    dtest = xgb.DMatrix(data=test_cpu, feature_names=feature_names)\n",
    "    clf = xgb.train(xgb_cpu_params, dtrain=dtrain,\n",
    "                num_boost_round=500,evals=watchlist,\n",
    "                early_stopping_rounds=None,maximize=True,\n",
    "                verbose_eval=100)\n",
    "    pred_cpu += clf.predict(dtest)\n",
    "    print('fold',i,'done')\n",
    "pred_cpu /= (i+1)\n",
    "\n",
    "timing_cpu[step] = time.time()-start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "617.4223990440369"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timing_gpu['train & predict']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "steps = ['read data & label encode','count encode','target encode','combine','train & predict']\n",
    "timing_gpu['Overall'] = sum([timing_gpu[i] for i in steps])\n",
    "steps.append('Overall')\n",
    "gpu_time = [timing_gpu[i] for i in steps]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f0fcd6fd6d8>"
      ]
     },
     "execution_count": 21,
     "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": [
    "timing_cpu['Overall'] = sum([timing_cpu[i] for i in steps[:-1]])\n",
    "speedup = [timing_cpu[i]/timing_gpu[i] for i in steps]\n",
    "df = pd.DataFrame({'steps':steps, 'speedup':speedup})\n",
    "df.plot.bar(x='steps', y='speedup', rot=0, figsize=(20,5), fontsize=15, title='GPU Speedup')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f12919d4048>"
      ]
     },
     "execution_count": 22,
     "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": [
    "cpu_time = [timing_cpu[i] for i in steps]\n",
    "df = pd.DataFrame({'GPU': gpu_time,'CPU': cpu_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
}