{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fast Training of Support Vector Machines for Survival Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This document demonstrates how to use the efficient implementation of *Survival Support Vector Machines* as proposed in\n",
    "\n",
    "> Pölsterl, S., Navab, N., and Katouzian, A.,\n",
    "> *Fast Training of Support Vector Machines for Survival Analysis*,\n",
    "> Machine Learning and Knowledge Discovery in Databases: European Conference,\n",
    "> ECML PKDD 2015, Porto, Portugal,\n",
    "> Lecture Notes in Computer Science, vol. 9285, pp. 243-259 (2015)\n",
    "\n",
    "The source code and installation instructions are available at https://github.com/sebp/scikit-survival.\n",
    "\n",
    "The main class of interest is ``sksurv.svm.FastSurvivalSVM``, which implements the different optimizers for training\n",
    "a Survival Support Vector Machine. Training data consists of $n$ triplets $(\\mathbf{x}_i, y_i, \\delta_i)$, where\n",
    "$\\mathbf{x}_i$ is a $d$-dimensional feature vector, $y_i > 0$ the survival time or time of censoring, and $\\delta_i \\in \\{0,1\\}$ the binary event indicator. Using the training data, the objective is to minimize the following function:\n",
    "\n",
    "\\begin{equation}\n",
    " \\arg \\min_{\\mathbf{w}, b} \\frac{1}{2} \\mathbf{w}^T \\mathbf{w}+ \\frac{\\alpha}{2} \\left[\n",
    " r \\sum_{i,j \\in \\mathcal{P}}\n",
    "  \\max(0, 1 - (\\mathbf{w}^T \\mathbf{x}_i - \\mathbf{w}^T \\mathbf{x}_j))^2\n",
    "+ (1 - r) \\sum_{i=0}^n \\left( \\zeta_{\\mathbf{w},b} (y_i, x_i, \\delta_i) \\right)^2\n",
    "\\right]\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\\zeta_{\\mathbf{w},b} (y_i, \\mathbf{x}_i, \\delta_i) =\n",
    "\\begin{cases}\n",
    "  \\max(0, y_i - \\mathbf{w}^T \\mathbf{x}_i - b) & \\text{if $\\delta_i = 0$,} \\\\\n",
    " y_i - \\mathbf{w}^T \\mathbf{x}_i - b & \\text{if $\\delta_i = 1$,} \\\\\n",
    "\\end{cases}\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\\mathcal{P} = \\{ (i, j)~|~y_i > y_j \\land \\delta_j = 1 \\}_{i,j=1,\\dots,n}\n",
    "\\end{equation}\n",
    "\n",
    "The hyper-parameter $\\alpha > 0$ determines the amount of regularization to apply: a smaller value increases the amount of regularization and a higher value reduces the amount of regularization. The hyper-parameter $r \\in [0; 1]$ determines the trade-off between the ranking objective and the regresson objective. If $r = 1$ it reduces to the ranking objective, and if $r = 0$ to the regression objective. If the regression objective is used, it is advised to log-transform the survival/censoring time first.\n",
    "\n",
    "In this example, I'm going to use the ranking objective ($r = 1$) and grid search to determine the best setting for the hyper-parameter $\\alpha$.\n",
    "\n",
    "The class ``sksurv.svm.FastSurvivalSVM`` adheres to interfaces used in [scikit-learn](http://scikit-learn.org) and thus it is possible to combine it with auxiliary classes and functions from scikit-learn. Here, I'm going to use [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.module_selection.GridSearchCV.html) to determine which set hyper-parameters performs best for the Veteran's Lung Cancer data. Since, we require an event indicator $\\delta_i$, which is boolean, and the survival/censoring time $y_i$ for training, we have to create a structured array that contains both information.\n",
    "\n",
    "But first, we have to import the classes we are going to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import ShuffleSplit, GridSearchCV\n",
    "\n",
    "from sksurv.datasets import load_veterans_lung_cancer\n",
    "from sksurv.column import encode_categorical\n",
    "from sksurv.metrics import concordance_index_censored\n",
    "from sksurv.svm import FastSurvivalSVM\n",
    "\n",
    "sns.set_style(\"whitegrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, load data of the *Veteran's Administration Lung Cancer Trial* from disk and convert it to numeric values. The data consists of 137 patients and 6 features. The  primary  outcome  measure  was  death (`Status`, `Survival_in_days`).\n",
    "The original data can be retrieved from http://lib.stat.cmu.edu/datasets/veteran.\n",
    "\n",
    "Note that it does not matter how you name the fields corresponding to the event indicator and time, as long as the event indicator comes first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x, y = load_veterans_lung_cancer()\n",
    "x = encode_categorical(data_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are essentially ready to start training, but before let's determine what the amount of censoring for this data is and plot the survival/censoring times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.6% of records are censored\n"
     ]
    }
   ],
   "source": [
    "n_censored = y.shape[0] - y[\"Status\"].sum()\n",
    "print(\"%.1f%% of records are censored\" % (n_censored / y.shape[0] * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f00ce922518>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f00cee2e828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9, 6))\n",
    "val, bins, patches = plt.hist((y[\"Survival_in_days\"][y[\"Status\"]],\n",
    "                               y[\"Survival_in_days\"][~y[\"Status\"]]),\n",
    "                              bins=30, stacked=True)\n",
    "plt.legend(patches, [\"Time of Death\", \"Time of Censoring\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to create an initial model with default parameters that is subsequently used in the grid search. We are going to use a Red-Black tree to speed up optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimator = FastSurvivalSVM(optimizer=\"rbtree\", max_iter=1000, tol=1e-6, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we define a function for evaluating the performance of models during grid search. We use Harrell's concordance index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_survival_model(model, X, y):\n",
    "    prediction = model.predict(X)\n",
    "    result = concordance_index_censored(y['Status'], y['Survival_in_days'], prediction)\n",
    "    return result[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last part of the setup specifies the set of parameters we want to try and how many repetitions of training and testing we want to perform for each parameter setting. In the end, the parameters that on average peformed best across all test sets (200 in this case) are selected. [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) can leverage multiple cores by evaluating multiple parameter settings concurrently (I use 4 jobs in this example)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = {'alpha': 2. ** np.arange(-12, 13, 2)}\n",
    "cv = ShuffleSplit(n_splits=200, test_size=0.5, random_state=0)\n",
    "gcv = GridSearchCV(estimator, param_grid, scoring=score_survival_model,\n",
    "                   n_jobs=4, iid=False, refit=False,\n",
    "                   cv=cv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, start the hyper-parameter search. This can take a while since a total of ``13 * 200 = 2600`` fits have to be evaluated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "gcv = gcv.fit(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check what is the best average performance across 200 random train/test splits we got and the corresponding hyper-parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.718221596570157, {'alpha': 0.00390625})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gcv.best_score_, gcv.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we retrieve all 200 test scores for each parameter setting and visualize their distribution by box plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_performance(gcv):\n",
    "    n_splits = gcv.cv.n_splits\n",
    "    cv_scores = {\"alpha\": [], \"test_score\": [], \"split\": []}\n",
    "    order = []\n",
    "    for i, params in enumerate(gcv.cv_results_[\"params\"]):            \n",
    "        name = \"%.5f\" % params[\"alpha\"]\n",
    "        order.append(name)\n",
    "        for j in range(n_splits):\n",
    "            vs = gcv.cv_results_[\"split%d_test_score\" % j][i]\n",
    "            cv_scores[\"alpha\"].append(name)\n",
    "            cv_scores[\"test_score\"].append(vs)\n",
    "            cv_scores[\"split\"].append(j)\n",
    "    df = pandas.DataFrame.from_dict(cv_scores)\n",
    "    _, ax = plt.subplots(figsize=(11, 6))\n",
    "    sns.boxplot(x=\"alpha\", y=\"test_score\", data=df, order=order, ax=ax)\n",
    "    _, xtext = plt.xticks()\n",
    "    for t in xtext:\n",
    "        t.set_rotation(\"vertical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f00ce819fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_performance(gcv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Kernel Survival Support Vector Machine\n",
    "\n",
    "This section demonstrates how to use the efficient implementation of *Kernel Survival Support Vector Machines* as proposed in\n",
    "\n",
    "> Pölsterl, S., Navab, N., and Katouzian, A.,\n",
    "> *An Efficient Training Algorithm for Kernel Survival Support Vector Machines*\n",
    "> 4th Workshop on Machine Learning in Life Sciences,\n",
    "> 23 September 2016, Riva del Garda, Italy\n",
    "\n",
    "As kernel we are going to use the clinical kernel, because it distinguishes between continuous, ordinal, and nominal attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sksurv.svm import FastKernelSurvivalSVM\n",
    "from sksurv.kernels import clinical_kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use `GridSearchCV` with a custom kernel, we need to pre-compute the squared kernel matrix and pass it to `GridSearchCV.fit` later. It would also be possible to construct `FastKernelSurvivalSVM` with `kernel=\"rbf\"` (or any other built-in kernel), which does not require pre-computing the kernel matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel_matrix = clinical_kernel(data_x)\n",
    "kssvm = FastKernelSurvivalSVM(optimizer=\"rbtree\", kernel=\"precomputed\", random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "kgcv = GridSearchCV(kssvm, param_grid, score_survival_model,\n",
    "                    n_jobs=4, iid=False, refit=False,\n",
    "                    cv=cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "kgcv = kgcv.fit(kernel_matrix, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, print the best average concordance index the corresponding parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7071426137273039, {'alpha': 0.015625})"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kgcv.best_score_, kgcv.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we visualize the distribution of test scores obtained via cross-validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f00ccedb128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_performance(kgcv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}