notebooks/4.0-ab-metadata-model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import xgboost as xgb\n",
    "from category_encoders import OneHotEncoder\n",
    "from pandas_profiling import ProfileReport\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import FunctionTransformer, MinMaxScaler, StandardScaler\n",
    "from sklearn_pandas import DataFrameMapper, gen_features\n",
    "\n",
    "sns.set_style(\"white\")\n",
    "\n",
    "ROOT_PATH = Path(\"..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "df = pd.read_csv(ROOT_PATH / \"data/raw/metadata.csv\")\n",
    "svc_ids = pd.read_json(ROOT_PATH / \"data/raw/song_vs_call.json\").squeeze()\n",
    "svc_df = df.loc[df.id.isin(svc_ids)].copy()\n",
    "\n",
    "with open(ROOT_PATH / \"data/processed/svc_split.json\") as svc_split_file:\n",
    "    svc_split = json.load(svc_split_file)\n",
    "    train_ids = svc_split[\"train_ids\"]\n",
    "    test_ids = svc_split[\"test_ids\"]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "# Add response variable\n",
    "type_col = svc_df.type.str.lower().str.replace(\" \", \"\").str.split(\",\")\n",
    "filtered_type_col = type_col.apply(lambda l: set(l) - {\"call\", \"song\"})\n",
    "svc_df[\"pred\"] = type_col.apply(lambda l: \"call\" in l).astype(int)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "# Add gender feature\n",
    "def filter_gender(labels):\n",
    "    if \"male\" in labels:\n",
    "        return \"male\"\n",
    "    elif \"female\" in labels:\n",
    "        return \"female\"\n",
    "    else:\n",
    "        return np.nan\n",
    "\n",
    "\n",
    "svc_df[\"gender\"] = type_col.apply(filter_gender)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [],
   "source": [
    "# Add age feature\n",
    "def filter_age(labels):\n",
    "    if \"adult\" in labels:\n",
    "        return \"adult\"\n",
    "    elif \"juvenile\" in labels:\n",
    "        return \"juvenile\"\n",
    "    else:\n",
    "        return np.nan\n",
    "\n",
    "\n",
    "svc_df[\"age\"] = type_col.apply(filter_age)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "# Set up date and time columns\n",
    "svc_df.date = pd.to_datetime(svc_df.date, format=\"%Y-%m-%d\", errors=\"coerce\")\n",
    "svc_df.time = pd.to_datetime(svc_df.time, format=\"%H:%M\", errors=\"coerce\")\n",
    "svc_df[\"month\"] = svc_df.date.dt.month\n",
    "svc_df[\"day\"] = svc_df.date.dt.day\n",
    "svc_df[\"hour\"] = svc_df.time.dt.hour\n",
    "svc_df[\"minute\"] = svc_df.time.dt.minute"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "Summarize dataset:   0%|          | 0/47 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "7ac7f70358d94b898c68a98cdf6dc56c"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "Generate report structure:   0%|          | 0/1 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "e648bb377a8a4956bbd76f4435e86375"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "Render HTML:   0%|          | 0/1 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "371ec34992364d4d9143edf7c6338afd"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "Export report to file:   0%|          | 0/1 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "2d5ac53d604e4bc49e92aa67e2cf59c9"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "profile = ProfileReport(svc_df, title=\"Metadata Report\")\n",
    "fname = \"metadata_report.html\"\n",
    "profile.to_file(f\"assets/{fname}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "keep_cols = [\n",
    "    \"id\",\n",
    "    \"gen\",\n",
    "    \"sp\",\n",
    "    \"ssp\",\n",
    "    \"en\",\n",
    "    \"lat\",\n",
    "    \"lng\",\n",
    "    \"time\",\n",
    "    \"date\",\n",
    "    \"gender\",\n",
    "    \"age\",\n",
    "    \"month\",\n",
    "    \"day\",\n",
    "    \"hour\",\n",
    "    \"minute\",\n",
    "]\n",
    "X_df, y_df = (\n",
    "    svc_df.reindex(columns=keep_cols).copy(),\n",
    "    svc_df.reindex(columns=[\"id\", \"pred\"]).copy(),\n",
    ")\n",
    "dt_feats = gen_features(\n",
    "    columns=[[\"month\"], [\"day\"], [\"hour\"], [\"minute\"]],\n",
    "    classes=[\n",
    "        SimpleImputer,\n",
    "        {\"class\": FunctionTransformer, \"func\": np.sin},\n",
    "        MinMaxScaler,\n",
    "    ],\n",
    ")\n",
    "n_components = 50\n",
    "feature_mapper = DataFrameMapper(\n",
    "    [\n",
    "        (\"id\", None),\n",
    "        ([\"gen\"], OneHotEncoder(drop_invariant=True, use_cat_names=True)),\n",
    "        ([\"sp\"], OneHotEncoder(drop_invariant=True, use_cat_names=True)),\n",
    "        ([\"en\"], OneHotEncoder(drop_invariant=True, use_cat_names=True)),\n",
    "        ([\"lat\"], [SimpleImputer(), StandardScaler()]),  # gaussian\n",
    "        ([\"lng\"], [SimpleImputer(), MinMaxScaler()]),  # bi-modal --> MinMaxScaler\n",
    "        # TODO: maybe later look into converting month / day into days since start of year\n",
    "        (\n",
    "            [\"month\"],\n",
    "            [\n",
    "                SimpleImputer(),\n",
    "                FunctionTransformer(lambda X: np.sin((X - 1) * 2 * np.pi / 12)),\n",
    "                StandardScaler(),  # gaussian\n",
    "            ],\n",
    "        ),\n",
    "        (\n",
    "            [\"day\"],\n",
    "            [\n",
    "                SimpleImputer(),\n",
    "                FunctionTransformer(lambda X: np.sin(X * 2 * np.pi / 31)),\n",
    "                MinMaxScaler(),  # uniform\n",
    "            ],\n",
    "        ),\n",
    "        # TODO: maybe later look into converting hour / minute into seconds since start of day\n",
    "        (\n",
    "            [\"hour\"],\n",
    "            [\n",
    "                SimpleImputer(),\n",
    "                FunctionTransformer(lambda X: np.sin(X * 2 * np.pi / 24)),\n",
    "                StandardScaler(),  # gaussian\n",
    "            ],\n",
    "        ),\n",
    "        (\n",
    "            [\"minute\"],\n",
    "            [\n",
    "                SimpleImputer(),\n",
    "                FunctionTransformer(lambda X: np.sin(X * 2 * np.pi / 60)),\n",
    "                MinMaxScaler(),  # uniform\n",
    "            ],\n",
    "        ),\n",
    "    ],\n",
    "    df_out=True,\n",
    ")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/adithyabalaji/.pyenv/versions/3.8.0/envs/pracds_final/lib/python3.8/site-packages/category_encoders/utils.py:21: FutureWarning: is_categorical is deprecated and will be removed in a future version.  Use is_categorical_dtype instead\n",
      "  elif pd.api.types.is_categorical(cols):\n",
      "/Users/adithyabalaji/.pyenv/versions/3.8.0/envs/pracds_final/lib/python3.8/site-packages/category_encoders/utils.py:21: FutureWarning: is_categorical is deprecated and will be removed in a future version.  Use is_categorical_dtype instead\n",
      "  elif pd.api.types.is_categorical(cols):\n",
      "/Users/adithyabalaji/.pyenv/versions/3.8.0/envs/pracds_final/lib/python3.8/site-packages/category_encoders/utils.py:21: FutureWarning: is_categorical is deprecated and will be removed in a future version.  Use is_categorical_dtype instead\n",
      "  elif pd.api.types.is_categorical(cols):\n"
     ]
    }
   ],
   "source": [
    "X_feat_df = feature_mapper.fit_transform(X_df, y_df[\"pred\"])\n",
    "X_train, X_test = (\n",
    "    X_feat_df[X_feat_df.id.isin(train_ids)].drop(columns=[\"id\"]),\n",
    "    X_feat_df[X_feat_df.id.isin(test_ids)].drop(columns=[\"id\"]),\n",
    ")\n",
    "y_train, y_test = (\n",
    "    y_df[y_df.id.isin(train_ids)].drop(columns=[\"id\"]).squeeze(),\n",
    "    y_df[y_df.id.isin(test_ids)].drop(columns=[\"id\"]).squeeze(),\n",
    ")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7496551724137931\n"
     ]
    }
   ],
   "source": [
    "lr = LogisticRegression()\n",
    "lr.fit(X_train, y_train)\n",
    "\n",
    "print(lr.score(X_test, y_test))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/adithyabalaji/.pyenv/versions/3.8.0/envs/pracds_final/lib/python3.8/site-packages/xgboost/sklearn.py:1146: UserWarning: The use of label encoder in XGBClassifier is deprecated and will be removed in a future release. To remove this warning, do the following: 1) Pass option use_label_encoder=False when constructing XGBClassifier object; and 2) Encode your labels (y) as integers starting with 0, i.e. 0, 1, 2, ..., [num_class - 1].\n",
      "  warnings.warn(label_encoder_deprecation_msg, UserWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7731034482758621\n"
     ]
    }
   ],
   "source": [
    "xgb_clf = xgb.XGBClassifier()\n",
    "eval_set = [(X_train, y_train), (X_test, y_test)]\n",
    "xgb_clf.fit(\n",
    "    X_train, y_train, eval_metric=[\"error\", \"logloss\"], eval_set=eval_set, verbose=False\n",
    ")\n",
    "\n",
    "print(xgb_clf.score(X_test, y_test))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Loss\n",
    "# retrieve performance metrics\n",
    "results = xgb_clf.evals_result()\n",
    "epochs = len(results[\"validation_0\"][\"error\"])\n",
    "x_axis = range(0, epochs)\n",
    "\n",
    "# plot log loss\n",
    "f, ax = plt.subplots()\n",
    "ax.plot(x_axis, results[\"validation_0\"][\"logloss\"], label=\"Train\")\n",
    "ax.plot(x_axis, results[\"validation_1\"][\"logloss\"], label=\"Test\")\n",
    "ax.legend()\n",
    "sns.despine(f, ax)\n",
    "plt.ylabel(\"Log Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.title(\"Log Loss vs Epochs (XGBoost Meta Model)\")\n",
    "\n",
    "f.tight_layout()\n",
    "fig_name = \"svc_meta_xgb_loss.png\"\n",
    "f.savefig(f\"assets/{fig_name}\", dpi=150);"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.331\n",
      "Test Loss:  0.507\n",
      "Train Accuracy: 0.879\n",
      "Test Accuracy:  0.773\n"
     ]
    }
   ],
   "source": [
    "xgb_train_acc = xgb_clf.score(X_train, y_train)\n",
    "xgb_test_acc = xgb_clf.score(X_test, y_test)\n",
    "\n",
    "print(f\"Train Loss: {results['validation_0']['logloss'][-1]:.3f}\")\n",
    "print(f\"Test Loss:  {results['validation_1']['logloss'][-1]:.3f}\")\n",
    "\n",
    "print(f\"Train Accuracy: {xgb_train_acc:.3f}\")\n",
    "print(f\"Test Accuracy:  {xgb_test_acc:.3f}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Feature importance\n",
    "# how it is calculated: https://stats.stackexchange.com/a/422480/311774\n",
    "N_feats = 10\n",
    "feat_imp = pd.Series(\n",
    "    xgb_clf.feature_importances_, index=X_train.columns, name=\"imp\"\n",
    ").nlargest(N_feats)\n",
    "\n",
    "f, ax = plt.subplots()\n",
    "ax.bar(feat_imp.index, feat_imp)\n",
    "sns.despine(f, ax, bottom=True)\n",
    "plt.setp(ax.get_xticklabels(), rotation=75)\n",
    "\n",
    "ax.set_xlabel(\"Feature Name\")\n",
    "ax.set_ylabel(\"Importance\")\n",
    "ax.set_title(f\"Importance vs Feature for the {N_feats} Largest Importances\")\n",
    "f.tight_layout()\n",
    "fig_name = \"svc_meta_xgb_imp.png\"\n",
    "f.savefig(f\"assets/{fig_name}\", dpi=150);"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}