{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Survival Analysis for Deep Learning\n",
"\n",
"Most machine learning algorithms have been developed to perform classification or regression. However, in clinical research we often want to estimate the time to and event, such as death or recurrence of cancer, which leads to a special type of learning task that is distinct from classification and regression. This task is termed *survival analysis*, but is also referred to as time-to-event analysis or reliability analysis.\n",
"Many machine learning algorithms have been adopted to perform survival analysis:\n",
"[Support Vector Machines](https://scholar.google.com/scholar?oi=bibs&cluster=18092275419152143443),\n",
"[Random Forest](https://scholar.google.com/scholar?cluster=16319510831191377024),\n",
"or [Boosting](https://scholar.google.com/scholar?cluster=14069073471114367075).\n",
"It has only been recently that survival analysis entered the era of deep learning, which is the focus of this post.\n",
"\n",
"You will learn how to train a convolutional neural network to predict time to a (generated) event from MNIST images, using a loss function specific to survival analysis. The [first part](#Primer-on-Survival-Analysis), will cover some basic terms and quantities used in survival analysis (feel free to skip this part if you are already familiar). In the [second part](#Generating-Synthetic-Survival-Data-from-MNIST), we will generate synthetic survival data from MNIST images and visualize it. In the [third part](#Cox's-Proportional-Hazards-Model), we will briefly revisit the most popular survival model of them all and learn how it can be used as a loss function for training a neural network.\n",
"[Finally](#Creating-a-Convolutional-Neural-Network-for-Survival-Analysis-on-MNIST), we put all the pieces together and train a convolutional neural network on MNIST and predict survival functions on the test data.\n",
"\n",
"\n",
"## Requirements:\n",
"\n",
"Please make sure you have the following packages installed. All are available via [PyPI](https://pypi.org) or [Anaconda](https://www.anaconda.com/distribution/).\n",
"\n",
"- [numpy](https://www.numpy.org/)\n",
"- [matplotlib](https://matplotlib.org/)\n",
"- [pandas](https://pandas.pydata.org/)\n",
"- [scikit-survival](https://github.com/sebp/scikit-survival/)\n",
"- [tensorflow](https://www.tensorflow.org/) < 2.0.0\n",
"\n",
"You can also run this notebook in [Google Colaboratory](https://colab.research.google.com/github/sebp/survival-cnn-estimator/blob/master/tutorial_tf1.ipynb) and install scikit-survival using the command below."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"!pip install scikit-survival"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Using Tensorflow: 1.15.2\n"
]
}
],
"source": [
"from typing import Any, Dict, Iterable, Tuple, Optional, Union\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import pandas as pd\n",
"from pathlib import Path\n",
"from sksurv.nonparametric import kaplan_meier_estimator\n",
"from sksurv.metrics import concordance_index_censored\n",
"import tensorflow as tf\n",
"from tensorflow.keras.datasets import mnist\n",
"\n",
"print(\"Using Tensorflow:\", tf.__version__)\n",
"tf.logging.set_verbosity(tf.logging.WARN)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from distutils.version import LooseVersion\n",
"\n",
"assert LooseVersion(tf.__version__) < LooseVersion(\"2.0.0\"), \\\n",
" \"This notebook requires TensorFlow 1.X.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Primer on Survival Analysis\n",
"\n",
"The objective in survival analysis is to establish a connection between covariates and the time of an event. The name *survival analysis* originates from clinical research, where predicting the time to death, i.e., survival, is often the main objective. Survival analysis is a type of regression problem (one wants to predict a continuous value), but with a twist. It differs from traditional regression by the fact that parts of the training data can only be partially observed – they are *censored*.\n",
"\n",
"As an example, consider a clinical study that has been carried out over a 1 year period as in the figure below."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Patient A was lost to follow-up after three months with no recorded event, patient B experienced an event four and a half months after enrollment, patient C withdrew from the study two months after enrollment, and patient E did not experience any event before the study ended. Consequently, the *exact time* of an event could only be recorded for patients B and D; their records are *uncensored*. For the remaining patients it is unknown whether they did or did not experience an event after termination of the study. The only valid information that is available for patients A, C, and E is that they were event-free up to their last follow-up. Therefore, their records are *censored*.\n",
"\n",
"Formally, each patient record consists of the time $t>0$ when an event occurred or the time $c>0$ of censoring. Since censoring and experiencing and event are mutually exclusive, it is common to define an event indicator $\\delta \\in \\{0;1\\}$ and the observable survival time $y>0$. The observable time $y$ of a right censored time of event is defined as\n",
"\n",
"$$\n",
"y = \\min(t, c) = \n",
"\\begin{cases} \n",
"t & \\text{if } \\delta = 1 , \\\\\n",
"c & \\text{if } \\delta = 0 .\n",
"\\end{cases}\n",
"$$\n",
"\n",
"Consequently, survival analysis demands for models that take partially observed, i.e., censored, event times into account.\n",
"\n",
"\n",
"## Basic Quantities\n",
"\n",
"Typically, the survival time is modelled as a continuous non-negative random variable $T$, from which basic quantities for time-to-event analysis can be derived, most importantly, the *survival function* and the *hazard function*.\n",
"\n",
"- The **survival function** $S(t)$ returns the probability of survival beyond time $t$ and is defined as $S(t) = P(T > t)$. It is non-increasing with $S(0) = 1$, and $S(\\infty) = 0$.\n",
"- The **hazard function** $h(t)$ denotes an approximate probability (it is not bounded from above) that an event occurs in the small time interval $[t; t + \\Delta[$, under the condition that an individual would remain event-free up to time $t$:\n",
"$$\n",
"h(t) = \\lim_{\\Delta t \\rightarrow 0} \\frac{P(t \\leq T < t + \\Delta t \\mid T \\geq t)}{\\Delta t} \\geq 0\n",
"$$\n",
"Alternative names for the hazard function are conditional failure rate, conditional mortality rate, or instantaneous failure rate. In contrast to the survival function, which describes the absence of an event, the hazard function provides information about the occurrence of an event."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Generating Synthetic Survival Data from MNIST\n",
"\n",
"To start off, we are using images from the MNIST dataset and will synthetically generate\n",
"survival times based on the digit each image represents.\n",
"We associate a survival time (or risk score) with each class of the ten digits in MNIST. First, we randomly assign each class label to one of four overall risk groups, such that some digits will correspond to better and others to worse survival. Next, we generate risk scores that indicate how big the risk of experiencing an event is, relative to each other."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
"\n",
"x_train = x_train.astype(np.float32) / 255.\n",
"x_test = x_test.astype(np.float32) / 255.\n",
"\n",
"y_train = y_train.astype(np.int32)\n",
"y_test = y_test.astype(np.int32)\n",
"\n",
"y = np.concatenate((y_train, y_test))"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
risk_score
\n",
"
risk_group
\n",
"
\n",
"
\n",
"
class_label
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
3.071
\n",
"
3
\n",
"
\n",
"
\n",
"
1
\n",
"
2.555
\n",
"
2
\n",
"
\n",
"
\n",
"
2
\n",
"
0.058
\n",
"
0
\n",
"
\n",
"
\n",
"
3
\n",
"
1.790
\n",
"
1
\n",
"
\n",
"
\n",
"
4
\n",
"
2.515
\n",
"
2
\n",
"
\n",
"
\n",
"
5
\n",
"
3.031
\n",
"
3
\n",
"
\n",
"
\n",
"
6
\n",
"
1.750
\n",
"
1
\n",
"
\n",
"
\n",
"
7
\n",
"
2.475
\n",
"
2
\n",
"
\n",
"
\n",
"
8
\n",
"
0.018
\n",
"
0
\n",
"
\n",
"
\n",
"
9
\n",
"
2.435
\n",
"
2
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" risk_score risk_group\n",
"class_label \n",
"0 3.071 3\n",
"1 2.555 2\n",
"2 0.058 0\n",
"3 1.790 1\n",
"4 2.515 2\n",
"5 3.031 3\n",
"6 1.750 1\n",
"7 2.475 2\n",
"8 0.018 0\n",
"9 2.435 2"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def make_risk_score_for_groups(y: np.ndarray,\n",
" n_groups: int = 4,\n",
" seed: int = 89) -> Tuple[pd.DataFrame, np.ndarray]:\n",
" rnd = np.random.RandomState(seed)\n",
"\n",
" # assign class labels `y` to one of `n_groups` risk groups\n",
" classes = np.unique(y)\n",
" group_assignment = {}\n",
" group_members = {}\n",
" groups = rnd.randint(n_groups, size=classes.shape)\n",
" for label, group in zip(classes, groups):\n",
" group_assignment[label] = group\n",
" group_members.setdefault(group, []).append(label)\n",
"\n",
" # assign risk score to each class label in `y`\n",
" risk_per_class = {}\n",
" for label in classes:\n",
" group_idx = group_assignment[label]\n",
" group = group_members[group_idx]\n",
" label_idx = group.index(label)\n",
" group_size = len(group)\n",
"\n",
" # allow risk scores in each group to vary slightly\n",
" risk_score = np.sqrt(group_idx + 1e-4) * 1.75\n",
" risk_score -= (label_idx - (group_size // 2)) / 25.\n",
" risk_per_class[label] = risk_score\n",
"\n",
" assignment = pd.concat((\n",
" pd.Series(risk_per_class, name=\"risk_score\"),\n",
" pd.Series(group_assignment, name=\"risk_group\")\n",
" ), axis=1).rename_axis(\"class_label\")\n",
" \n",
" risk_scores = np.array([risk_per_class[yy] for yy in y])\n",
" return assignment, risk_scores\n",
"\n",
"\n",
"risk_score_assignment, risk_scores = make_risk_score_for_groups(y)\n",
"\n",
"risk_score_assignment.round(3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see that class labels 2 and 8 belong to risk group 0, which has the lowest risk (close to zero). Risk group 1 corresponds to a risk score of about 1.7, risk group 2 of about 2.5, and risk group 3 is the group with the highest risk score of about 3.\n",
"\n",
"To generate survival times from risk scores, we are going to follow the protocol of\n",
"[Bender et al](https://scholar.google.com/scholar?cluster=11575471310627475868). We choose the exponential distribution for the survival time. Its probability density function is $f(t\\,|\\,\\lambda) = \\lambda \\exp(-\\lambda t)$, where $\\lambda > 0$ is a scale parameter that is the inverse of the expectation: $E(T) = \\frac{1}{\\lambda}$. The exponential distribution results in a relatively simple time-to-event model with no memory, because the hazard rate is constant: $h(t) = \\lambda$. For more complex cases, refer to the paper by [Bender et al](https://scholar.google.com/scholar?cluster=11575471310627475868).\n",
"\n",
"Here, we choose $\\lambda$ such that the mean survival time is 365 days. Finally, we randomly censor survival times drawing times of censoring from a uniform distribution such that we approximately obtain the desired amount of 45% censoring. The generated survival data comprises an observed time and a boolean event indicator for each MNIST image."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"46.19% samples are right censored in training data.\n",
"46.33% samples are right censored in test data.\n"
]
}
],
"source": [
"class SurvivalTimeGenerator:\n",
"\n",
" def __init__(self,\n",
" num_samples: int,\n",
" mean_survival_time: float,\n",
" prob_censored: float) -> None:\n",
" self.num_samples = num_samples\n",
" self.mean_survival_time = mean_survival_time\n",
" self.prob_censored = prob_censored\n",
"\n",
" def gen_censored_time(self,\n",
" risk_score: np.ndarray,\n",
" seed: int = 89) -> Tuple[np.ndarray,np.ndarray]:\n",
" rnd = np.random.RandomState(seed)\n",
" # generate survival time\n",
" baseline_hazard = 1. / self.mean_survival_time\n",
" scale = baseline_hazard * np.exp(risk_score)\n",
" u = rnd.uniform(low=0, high=1, size=risk_score.shape[0])\n",
" t = -np.log(u) / scale\n",
"\n",
" # generate time of censoring\n",
" qt = np.quantile(t, 1.0 - self.prob_censored)\n",
" c = rnd.uniform(low=t.min(), high=qt)\n",
"\n",
" # apply censoring\n",
" observed_event = t <= c\n",
" observed_time = np.where(observed_event, t, c)\n",
" return observed_time, observed_event\n",
"\n",
"\n",
"surv_gen = SurvivalTimeGenerator(\n",
" num_samples=y.shape[0],\n",
" mean_survival_time=365.,\n",
" prob_censored=.45\n",
")\n",
"time, event = surv_gen.gen_censored_time(risk_scores)\n",
"time_train = time[:y_train.shape[0]]\n",
"event_train = event[:y_train.shape[0]]\n",
"time_test = time[y_train.shape[0]:]\n",
"event_test = event[y_train.shape[0]:]\n",
"\n",
"print(\"%.2f%% samples are right censored in training data.\" % (np.sum(~event_train) * 100. / len(event_train)))\n",
"print(\"%.2f%% samples are right censored in test data.\" % (np.sum(~event_test) * 100. / len(event_test)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can use the generated censored data and estimate the survival function $S(t)$ to see what the risk scores actually mean in terms of survival. We stratify the training data by class label, and estimate the corresponding survival function using the non-parametric [Kaplan-Meier estimator](https://en.wikipedia.org/wiki/Kaplan%E2%80%93Meier_estimator)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"styles = ('-', '--', '-.', ':')\n",
"\n",
"plt.figure(figsize=(6, 4.5))\n",
"for row in risk_score_assignment.itertuples():\n",
" mask = y_train == row.Index\n",
" coord_x, coord_y = kaplan_meier_estimator(event_train[mask], time_train[mask])\n",
" ls = styles[row.risk_group]\n",
" plt.step(coord_x, coord_y, where=\"post\", label=f\"Class {row.Index}\", linestyle=ls)\n",
"plt.ylim(0, 1)\n",
"plt.ylabel(\"Probability of survival $P(T > t)$\")\n",
"plt.xlabel(\"Time $t$\")\n",
"plt.grid()\n",
"plt.legend()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Classes 0 and 5 (dotted lines) correspond to risk group 3, which has the highest risk score. The corresponding survival functions drop most quickly, which is exactly what we wanted. On the other end of the spectrum are classes 2 and 8 (solid lines) belonging to risk group 0 with the lowest risk.\n",
"\n",
"## Evaluating Predictions\n",
"\n",
"One important aspect for survival analysis is that both the training data and the test data are subject to censoring, because we are unable to observe the exact time of an event no matter how the data was split. Therefore, performance measures need to account for censoring. The most widely used performance measure is Harrell's concordance index. Given a set of (predicted) risk scores and observed times, it checks whether the ordering by risk scores is concordant with the ordering by actual survival time. While Harrell's concordance index is widely used, it has its flaws, in particular when data is highly censored. Please refer to my [previous post on evaluating survival models](https://k-d-w.org/blog/111/evaluating-survival-models) for more details.\n",
"\n",
"We can take the risk score from which we generated survival times to check how good a model would perform if we knew the actual risk score."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Concordance index on test data with actual risk scores: 0.705\n"
]
}
],
"source": [
"cindex = concordance_index_censored(event_test, time_test, risk_scores[y_train.shape[0]:])\n",
"\n",
"print(f\"Concordance index on test data with actual risk scores: {cindex[0]:.3f}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Surprisingly, we do not obtain a perfect result of 1.0. The reason for this is that generated survival times are randomly distributed based on risk scores and not deterministic functions of the risk score. Therefore, any model we will train on this data should not be able to exceed this performance value."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Cox's Proportional Hazards Model\n",
"\n",
"By far the most widely used model to learn from censored survival data, is\n",
"[Cox's proportional hazards model](https://scholar.google.com/scholar?cluster=17981786408695305487) model.\n",
"It models the hazard function $h(t_i)$\n",
"of the $i$-th subject, conditional on the feature vector $\\mathbf{x}_i \\in \\mathbb{R}^p$,\n",
"as the product of an unspecified baseline hazard function $h_0$ (more on that later) and an\n",
"exponential function of the linear model $\\mathbf{x}_i^\\top \\mathbf{\\beta}$:\n",
"$$\n",
"h(t | x_{i1}, \\ldots, x_{ip}) = h_0(t) \\exp \\left( \\sum_{j=1}^p x_{ij} \\beta_j \\right)\n",
"\\Leftrightarrow\n",
"\\log \\frac{h(t | \\mathbf{x}_i)}{h_0 (t)} = \\mathbf{x}_i^\\top \\mathbf{\\beta} ,\n",
"$$\n",
"where $\\mathbf{\\beta} \\in \\mathbb{R}^p$ are the coefficients associated with each of the\n",
"$p$ features, and no intercept term is included in the model.\n",
"The key is that the hazard function is split into two parts: the baseline hazard function $h_0$ only depends on the time $t$, whereas the exponential is independent of time and only depends on the covariates $\\mathbf{x}_i$.\n",
"\n",
"Cox's proportional hazards model is fitted by maximizing the partial likelihood function, which is based on the probability that the $i$-th individual experiences\n",
"an event at time $t_i$, given that there is one event at time point $t_i$.\n",
"As we will see, by specifying the hazard function as above, the baseline hazard function $h_0$\n",
"can be eliminated and does not need be defined for finding the coefficients $\\mathbf{\\beta}$.\n",
"Let $\\mathcal{R}_i = \\{ j\\,|\\,y_j \\geq y_i \\}$\n",
"be the risk set, i.e., the set of subjects who remained event-free shortly before time point $y_i$,\n",
"and $I(\\cdot)$ the indicator function, then we have\n",
"\n",
"$$\n",
"\\begin{split}\n",
"&P(\\text{subject experiences event at $y_i$} \\mid \\text{one event at $y_i$}) \\\\\n",
"=& \\frac{P(\\text{subject experiences event at $y_i$} \\mid \\text{event-free up to $y_i$})}\n",
"{P (\\text{one event at $y_i$} \\mid \\text{event-free up to $y_i$})} \\\\\n",
"=& \\frac{h(y_i | \\mathbf{x}_i)}{ \\sum_{j=1}^n I(y_j \\geq y_i) h(y_j | \\mathbf{x}_j) } \\\\\n",
"=& \\frac{h_0(y_i) \\exp(\\mathbf{x}_i^\\top \\mathbf{\\beta})}\n",
"{ \\sum_{j=1}^n I(y_j \\geq y_i) h_0(y_j) \\exp(\\mathbf{x}_j^\\top \\mathbf{\\beta}) } \\\\\n",
"=& \\frac{\\exp( \\mathbf{x}_i^\\top \\beta)}{\\sum_{j \\in \\mathcal{R}_i} \\exp( \\mathbf{x}_j^\\top \\beta)} .\n",
"\\end{split}\n",
"$$\n",
"\n",
"By multiplying the conditional probability from above for all patients who experienced an event, and taking the logarithm, we obtain the *partial likelihood function*:\n",
"\n",
"$$\n",
"\\widehat{\\mathbf{\\beta}} = \\arg\\max_{\\mathbf{\\beta}}~\n",
"\\log\\,PL(\\mathbf{\\beta}) = \\sum_{i=1}^n \\delta_i \\left[ \\mathbf{x}_i^\\top \\mathbf{\\beta}\n",
"- \\log \\left( \\sum_{j \\in \\mathcal{R}_i} \\exp( \\mathbf{x}_j^\\top \\mathbf{\\beta}) \\right) \\right] .\n",
"$$\n",
"\n",
"\n",
"## Non-linear Survival Analysis with Neural Networks\n",
"\n",
"Cox's proportional hazards model as described above is a linear model, i.e., the predicted risk score is a linear combination of features. However, the model can easily be extended to the non-linear case by just replacing the linear predictor with the output of a neural network with parameters $\\mathbf{\\Theta}$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This has been realized early on and was originally proposed in the work of [Faraggi and Simon](https://scholar.google.com/scholar?cluster=8523249692591517459) back in 1995. Farragi and Simon explore multilayer perceptrons, but the same loss can be used in combination with more advanced architectures such as convolutional neural networks or recurrent neural networks.\n",
"Therefore, it is natural to also use the same loss function in the era of deep learning.\n",
"However, this transition is not so easy as it may seem and comes with some caveats, both for training and for evaluation.\n",
"\n",
"### Computing the Loss Function\n",
"\n",
"When implementing the Cox PH loss function, the problematic part is the inner sum over the risk set:\n",
"$\\sum_{j \\in \\mathcal{R}_i} \\exp( \\mathbf{x}_j^\\top \\mathbf{\\beta})$. Note that the risk set is defined as $\\mathcal{R}_i = \\{ j\\,|\\,y_j \\geq y_i \\}$, which implies an ordering according to observed times $y_i$, which may lead to quadratic complexity if implemented naively. Ideally, we want to sort the data once in descending order by survival time and then incrementally update the inner sum, which leads to a linear complexity to compute the loss (ignoring the time for sorting).\n",
"\n",
"Another problem is that the risk set for the subject with the smallest uncensored survival time is over the whole dataset. This is usually impractical, because we may not be able to keep the whole dataset in GPU memory. If we use mini-batches instead, as it's the norm, (i) we cannot compute the exact loss, because we may not have access to all samples in the risk set, and (ii) we need to sort each mini-batch by observed time, instead of sorting the whole data once.\n",
"\n",
"For practical purposes, computing the Cox PH loss over a mini-batch is usually fine, as long as the batch contains several uncensored samples, because otherwise the outer sum in the partial likelihood function would be over an empty set.\n",
"Here, we implement the sum over the risk set by multiplying the exponential of the predictions (as a row vector) by a squared boolean matrix that contains each sample's risk set as its rows. The sum over the risk set for each sample is then equivalent to a row-wise summation."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def _make_riskset(time: np.ndarray) -> np.ndarray:\n",
" \"\"\"Compute mask that represents each sample's risk set.\n",
"\n",
" Parameters\n",
" ----------\n",
" time : np.ndarray, shape=(n_samples,)\n",
" Observed event time sorted in descending order.\n",
"\n",
" Returns\n",
" -------\n",
" risk_set : np.ndarray, shape=(n_samples, n_samples)\n",
" Boolean matrix where the `i`-th row denotes the\n",
" risk set of the `i`-th instance, i.e. the indices `j`\n",
" for which the observer time `y_j >= y_i`.\n",
" \"\"\"\n",
" assert time.ndim == 1, \"expected 1D array\"\n",
"\n",
" # sort in descending order\n",
" o = np.argsort(-time, kind=\"mergesort\")\n",
" n_samples = len(time)\n",
" risk_set = np.zeros((n_samples, n_samples), dtype=np.bool_)\n",
" for i_org, i_sort in enumerate(o):\n",
" ti = time[i_sort]\n",
" k = i_org\n",
" while k < n_samples and ti == time[o[k]]:\n",
" k += 1\n",
" risk_set[i_sort, o[:k]] = True\n",
" return risk_set\n",
"\n",
"\n",
"class InputFunction:\n",
" \"\"\"Callable input function that computes the risk set for each batch.\n",
" \n",
" Parameters\n",
" ----------\n",
" images : np.ndarray, shape=(n_samples, height, width)\n",
" Image data.\n",
" time : np.ndarray, shape=(n_samples,)\n",
" Observed time.\n",
" event : np.ndarray, shape=(n_samples,)\n",
" Event indicator.\n",
" num_epochs : int, optional, default=1\n",
" Number of epochs.\n",
" batch_size : int, optional, default=64\n",
" Number of samples per batch.\n",
" drop_last : int, optional, default=False\n",
" Whether to drop the last incomplete batch.\n",
" shuffle : bool, optional, default=False\n",
" Whether to shuffle data.\n",
" seed : int, optional, default=89\n",
" Random number seed.\n",
" \"\"\"\n",
"\n",
" def __init__(self,\n",
" images: np.ndarray,\n",
" time: np.ndarray,\n",
" event: np.ndarray,\n",
" num_epochs: int= 1,\n",
" batch_size: int = 64,\n",
" drop_last: bool = False,\n",
" shuffle: bool = False,\n",
" seed: int = 89) -> None:\n",
" if images.ndim == 3:\n",
" images = images[..., np.newaxis]\n",
" self.images = images\n",
" self.time = time\n",
" self.event = event\n",
" self.num_epochs = num_epochs\n",
" self.batch_size = batch_size\n",
" self.drop_last = drop_last\n",
" self.shuffle = shuffle\n",
" self.seed = seed\n",
"\n",
" def size(self) -> int:\n",
" \"\"\"Total number of samples.\"\"\"\n",
" return self.images.shape[0]\n",
"\n",
" def steps_per_epoch(self) -> int:\n",
" \"\"\"Number of batches for one epoch.\"\"\"\n",
" return int(np.floor(self.size() / self.batch_size))\n",
"\n",
" def _get_data_batch(self, index: np.ndarray) -> Tuple[np.ndarray, Dict[str, np.ndarray]]:\n",
" \"\"\"Compute risk set for samples in batch.\"\"\"\n",
" time = self.time[index]\n",
" event = self.event[index]\n",
" images = self.images[index]\n",
"\n",
" labels = {\n",
" \"label_event\": event.astype(np.int32),\n",
" \"label_time\": time.astype(np.float32),\n",
" \"label_riskset\": _make_riskset(time)\n",
" }\n",
" return images, labels\n",
"\n",
" def _iter_data(self) -> Iterable[Tuple[np.ndarray, Dict[str, np.ndarray]]]:\n",
" \"\"\"Generator that yields one batch at a time.\"\"\"\n",
" index = np.arange(self.size())\n",
" rnd = np.random.RandomState(self.seed)\n",
"\n",
" for _ in range(self.num_epochs):\n",
" if self.shuffle:\n",
" rnd.shuffle(index)\n",
" for b in range(self.steps_per_epoch()):\n",
" start = b * self.batch_size\n",
" idx = index[start:(start + self.batch_size)]\n",
" yield self._get_data_batch(idx)\n",
"\n",
" if not self.drop_last:\n",
" start = self.steps_per_epoch() * self.batch_size\n",
" idx = index[start:]\n",
" yield self._get_data_batch(idx)\n",
"\n",
" def _get_shapes(self) -> Tuple[tf.TensorShape, Dict[str, tf.TensorShape]]:\n",
" \"\"\"Return shapes of data returned by `self._iter_data`.\"\"\"\n",
" batch_size = self.batch_size if self.drop_last else None\n",
" h, w, c = self.images.shape[1:]\n",
" images = tf.TensorShape([batch_size, h, w, c])\n",
"\n",
" labels = {k: tf.TensorShape((batch_size,))\n",
" for k in (\"label_event\", \"label_time\")}\n",
" labels[\"label_riskset\"] = tf.TensorShape((batch_size, batch_size))\n",
" return images, labels\n",
"\n",
" def _get_dtypes(self) -> Tuple[tf.DType, Dict[str, tf.DType]]:\n",
" \"\"\"Return dtypes of data returned by `self._iter_data`.\"\"\"\n",
" labels = {\"label_event\": tf.int32,\n",
" \"label_time\": tf.float32,\n",
" \"label_riskset\": tf.bool}\n",
" return tf.float32, labels\n",
"\n",
" def _make_dataset(self) -> tf.data.Dataset:\n",
" \"\"\"Create dataset from generator.\"\"\"\n",
" ds = tf.data.Dataset.from_generator(\n",
" self._iter_data,\n",
" self._get_dtypes(),\n",
" self._get_shapes()\n",
" )\n",
" return ds\n",
"\n",
" def __call__(self) -> Tuple[tf.Tensor, Dict[str, tf.Tensor]]:\n",
" ds = self._make_dataset()\n",
" next_x, next_y = ds.make_one_shot_iterator().get_next()\n",
" return next_x, next_y\n",
"\n",
"\n",
"def safe_normalize(x: tf.Tensor) -> tf.Tensor:\n",
" \"\"\"Normalize risk scores to avoid exp underflowing.\n",
"\n",
" Note that only risk scores relative to each other matter.\n",
" If minimum risk score is negative, we shift scores so minimum\n",
" is at zero.\n",
" \"\"\"\n",
" x_min = tf.reduce_min(x, axis=0)\n",
" c = tf.zeros_like(x_min)\n",
" norm = tf.where(x_min < 0, -x_min, c)\n",
" return x + norm\n",
"\n",
"\n",
"def logsumexp_masked(risk_scores: tf.Tensor,\n",
" mask: tf.Tensor,\n",
" axis: int = 0,\n",
" keepdims: Optional[bool] = None) -> tf.Tensor:\n",
" \"\"\"Compute logsumexp across `axis` for entries where `mask` is true.\"\"\"\n",
" risk_scores.get_shape().assert_same_rank(mask.get_shape())\n",
"\n",
" with tf.name_scope(\"logsumexp_masked\", values=[risk_scores, mask]):\n",
" mask_f = tf.cast(mask, risk_scores.dtype)\n",
" risk_scores_masked = tf.multiply(risk_scores, mask_f)\n",
" # for numerical stability, substract the maximum value\n",
" # before taking the exponential\n",
" amax = tf.reduce_max(risk_scores_masked, axis=axis, keepdims=True)\n",
" risk_scores_shift = risk_scores_masked - amax\n",
"\n",
" exp_masked = tf.multiply(tf.exp(risk_scores_shift), mask_f)\n",
" exp_sum = tf.reduce_sum(exp_masked, axis=axis, keepdims=True)\n",
" output = amax + tf.log(exp_sum)\n",
" if not keepdims:\n",
" output = tf.squeeze(output, axis=axis)\n",
" return output\n",
"\n",
"\n",
"def coxph_loss(event: tf.Tensor,\n",
" riskset: tf.Tensor,\n",
" predictions: tf.Tensor,\n",
" weights: Union[tf.Tensor, float] = 1.0,\n",
" scope: Optional[str] = None,\n",
" loss_collection: str = tf.GraphKeys.LOSSES,\n",
" reduction: str = tf.losses.Reduction.SUM_BY_NONZERO_WEIGHTS):\n",
" \"\"\"Negative partial log-likelihood of Cox's proportional\n",
" hazards model.\n",
"\n",
" Parameters\n",
" ----------\n",
" event : tf.Tensor\n",
" Binary vector where 1 indicates an event 0 censoring.\n",
" riskset : tf.Tensor\n",
" Boolean matrix where the `i`-th row denotes the\n",
" risk set of the `i`-th instance, i.e. the indices `j`\n",
" for which the observer time `y_j >= y_i`.\n",
" predictions : tf.Tensor\n",
" The predicted outputs. Must be a rank 2 tensor.\n",
" weights : tf.Tensor|float\n",
" Weight of loss. Either a scalar or a Tensor containing\n",
" weights of each instance.\n",
" scope : str|None\n",
" The scope for the operations performed in computing the loss.\n",
" loss_collection : str\n",
" Collection to which the loss will be added.\n",
" reduction : str\n",
" Type of reduction to apply to loss.\n",
"\n",
" Returns\n",
" -------\n",
" loss : tf.Tensor\n",
" Scalar loss.\n",
" \"\"\"\n",
" pred_shape = predictions.get_shape()\n",
" if pred_shape.ndims != 2:\n",
" raise ValueError(\"Rank mismatch: Rank of predictions (received %s) should \"\n",
" \"be 2.\" % pred_shape.ndims)\n",
"\n",
" if pred_shape[1].value is None:\n",
" raise ValueError(\"Last dimension of predictions must be known.\")\n",
"\n",
" if pred_shape[1].value != 1:\n",
" raise ValueError(\"Dimension mismatch: Last dimension of predictions \"\n",
" \"(received %s) must be 1.\" % pred_shape[1].value)\n",
"\n",
" if event.get_shape().ndims != pred_shape.ndims:\n",
" raise ValueError(\"Rank mismatch: Rank of predictions (received %s) should \"\n",
" \"equal rank of event (received %s)\" % (\n",
" pred_shape.ndims, event.get_shape().ndims))\n",
"\n",
" if riskset.get_shape().ndims != 2:\n",
" raise ValueError(\"Rank mismatch: Rank of riskset (received %s) should \"\n",
" \"be 2.\" % riskset.get_shape().ndims)\n",
"\n",
" with tf.name_scope(scope, 'coxph_loss', [predictions, event, riskset]) as scope:\n",
" event = tf.cast(event, predictions.dtype)\n",
" predictions = safe_normalize(predictions)\n",
"\n",
" with tf.name_scope('assertions', values=[event, riskset]):\n",
" assertions = (\n",
" tf.assert_less_equal(event, 1.),\n",
" tf.assert_greater_equal(event, 0.),\n",
" tf.assert_type(riskset, tf.bool)\n",
" )\n",
"\n",
" with tf.control_dependencies(assertions):\n",
" # move batch dimension to the end so predictions get broadcast\n",
" # row-wise when multiplying by riskset\n",
" pred_t = tf.transpose(predictions)\n",
" # compute log of sum over risk set for each row\n",
" rr = logsumexp_masked(pred_t, riskset, axis=1, keepdims=True)\n",
" assert rr.get_shape().as_list() == predictions.get_shape().as_list()\n",
"\n",
" losses = tf.multiply(event, rr - predictions)\n",
" loss = tf.losses.compute_weighted_loss(\n",
" losses,\n",
" weights=weights,\n",
" scope=scope,\n",
" loss_collection=loss_collection,\n",
" reduction=reduction)\n",
"\n",
" return loss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To monitor the training process, we would like to compute the concordance index with respect to a separate validation set. Similar to the Cox PH loss, the concordance index needs access to predicted risk scores and ground truth of *all* samples in the validation data. While we had to opt for computing the Cox PH loss over a mini-batch, I would not recommend this for the validation data. For small batch sizes and/or high amount of censoring, the estimated concordance index would be quite volatile, which makes it very hard to interpret. In addition, the validation data is usually considerably smaller than the training data, therefore we can collect predictions for the whole validation data and compute the concordance index accurately."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.core.framework import summary_pb2\n",
"\n",
"\n",
"def _to_scalar_protobuf(name: str, value: Any) -> summary_pb2.Summary:\n",
" value = float(value)\n",
" buf = summary_pb2.Summary(value=[summary_pb2.Summary.Value(\n",
" tag=name, simple_value=value)])\n",
" return buf\n",
"\n",
"\n",
"class EvalCindexHook(tf.train.SessionRunHook):\n",
" \"\"\"Computes concordance index across one epoch.\n",
"\n",
" Collects ground truth and predicted risk score\n",
" until session ends, i.e., `OutOfRangeError` is raised.\n",
" The concordance index is computed across collected\n",
" values and written to protocol buffer to display\n",
" in TensorBoard.\n",
"\n",
" Parameters\n",
" ----------\n",
" label_time : tf.Tensor\n",
" Tensor containing observed time for one batch.\n",
" label_event_indicator : tf.Tensor\n",
" Tensor containing event indicator for one batch.\n",
" prediction : tf.Tensor\n",
" Tensor containing predicted risk score for one batch.\n",
" \"\"\"\n",
"\n",
" def __init__(self,\n",
" label_time: tf.Tensor,\n",
" label_event_indicator: tf.Tensor,\n",
" prediction: tf.Tensor,\n",
" output_dir: str) -> None:\n",
" self._label_time = label_time\n",
" self._label_event_indicator = label_event_indicator\n",
" self._prediction = prediction\n",
"\n",
" self._writer = tf.summary.FileWriterCache.get(output_dir)\n",
"\n",
" def begin(self) -> None:\n",
" self._global_step_tensor = tf.train.get_or_create_global_step()\n",
" if self._global_step_tensor is None:\n",
" raise RuntimeError(\"Global step should be created.\")\n",
" self._data = {\n",
" \"label_time\": [],\n",
" \"label_event\": [],\n",
" \"prediction\": []\n",
" }\n",
" self._next_step = None\n",
"\n",
" def before_run(self,\n",
" run_context: tf.train.SessionRunContext) -> tf.train.SessionRunArgs:\n",
" fetches = {\n",
" \"global_step\": self._global_step_tensor,\n",
" \"label_time\": self._label_time,\n",
" \"label_event\": self._label_event_indicator,\n",
" \"prediction\": self._prediction\n",
" }\n",
" return tf.train.SessionRunArgs(fetches=fetches)\n",
"\n",
" def after_run(self,\n",
" run_context: tf.train.SessionRunContext,\n",
" run_values: tf.train.SessionRunValues) -> None:\n",
" global_step = run_values.results[\"global_step\"]\n",
"\n",
" if self._next_step is None:\n",
" self._writer.add_session_log(\n",
" tf.SessionLog(status=tf.SessionLog.START), global_step)\n",
"\n",
" for k, v in self._data.items():\n",
" v.append(run_values.results[k].squeeze())\n",
"\n",
" self._next_step = global_step + 1\n",
"\n",
" def _log_and_write(self, global_step: int, results: Dict[str, float]) -> None:\n",
" msg = [f\"global_step = {global_step}\"]\n",
" for k, v in results.items():\n",
" msg.append(f\"{k} = {v:.3f}\")\n",
" buf = _to_scalar_protobuf(f\"metrics/{k}\", v)\n",
" self._writer.add_summary(buf, global_step=global_step)\n",
"\n",
" tf.logging.info(\", \".join(msg))\n",
"\n",
" def end(self, session: tf.Session) -> None:\n",
" if self._next_step is None:\n",
" return\n",
"\n",
" data = {}\n",
" for k, v in self._data.items():\n",
" data[k] = np.concatenate(v)\n",
"\n",
" results = concordance_index_censored(\n",
" data[\"label_event\"] == 1,\n",
" data[\"label_time\"],\n",
" data[\"prediction\"])\n",
"\n",
" data = {}\n",
" names = (\"cindex\", \"concordant\", \"discordant\", \"tied_risk\")\n",
" for k, v in zip(names, results):\n",
" data[k] = v\n",
" self._log_and_write(self._next_step - 1, data)\n",
" del self._data\n",
" self._writer.flush()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating a Convolutional Neural Network for Survival Analysis on MNIST\n",
"\n",
"Finally, after many considerations, we can create a convolutional neural network (CNN) to learn a high-level representation from MNIST digits such that we can estimate each image's survival function. The CNN follows the LeNet architecture where the last linear has one output unit that corresponds to the predicted risk score. The predicted risk score, together with the binary event indicator and risk set, are the input to the Cox PH loss."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def model_fn(features, labels, mode, params):\n",
" is_training = mode == tf.estimator.ModeKeys.TRAIN\n",
"\n",
" model = tf.keras.Sequential([\n",
" tf.keras.layers.Conv2D(6, kernel_size=(5, 5), activation='relu', name='conv_1'),\n",
" tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),\n",
" tf.keras.layers.Conv2D(16, (5, 5), activation='relu', name='conv_2'),\n",
" tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),\n",
" tf.keras.layers.Flatten(),\n",
" tf.keras.layers.Dense(120, activation='relu', name='dense_1'),\n",
" tf.keras.layers.Dense(84, activation='relu', name='dense_2'),\n",
" tf.keras.layers.Dense(1, activation='linear', name='dense_3')\n",
" ])\n",
"\n",
" risk_score = model(features, training=is_training)\n",
"\n",
" loss = None\n",
" train_op = None\n",
" predictions = None\n",
" evaluation_hooks = None\n",
" if mode == tf.estimator.ModeKeys.PREDICT:\n",
" predictions = {\"risk_score\": risk_score}\n",
" else:\n",
" loss = coxph_loss(\n",
" event=tf.expand_dims(labels[\"label_event\"], axis=1),\n",
" riskset=labels[\"label_riskset\"],\n",
" predictions=risk_score\n",
" )\n",
"\n",
" if is_training:\n",
" optim = tf.train.AdamOptimizer(learning_rate=params[\"learning_rate\"])\n",
" gs = tf.train.get_or_create_global_step()\n",
" train_op = tf.contrib.layers.optimize_loss(loss, gs,\n",
" learning_rate=None,\n",
" optimizer=optim)\n",
" else:\n",
" evaluation_hooks = [EvalCindexHook(\n",
" label_time=labels[\"label_time\"],\n",
" label_event_indicator=labels[\"label_event\"],\n",
" prediction=risk_score,\n",
" output_dir=Path(params[\"model_dir\"]) / \"cindex\")]\n",
"\n",
" return tf.estimator.EstimatorSpec(\n",
" mode=mode,\n",
" loss=loss,\n",
" train_op=train_op,\n",
" predictions=predictions,\n",
" evaluation_hooks=evaluation_hooks\n",
" )\n",
"\n",
"\n",
"train_spec = tf.estimator.TrainSpec(\n",
" InputFunction(x_train, time_train, event_train,\n",
" num_epochs=15,\n",
" drop_last=True,\n",
" shuffle=True)\n",
")\n",
"\n",
"eval_spec = tf.estimator.EvalSpec(\n",
" InputFunction(x_test, time_test, event_test),\n",
" steps=None,\n",
" start_delay_secs=10,\n",
" throttle_secs=10,\n",
")\n",
"\n",
"params = {\n",
" \"learning_rate\": 0.0001,\n",
" \"model_dir\": \"ckpts-mnist-cnn\",\n",
"}\n",
"\n",
"config = tf.estimator.RunConfig(\n",
" model_dir=params[\"model_dir\"],\n",
" save_checkpoints_steps=train_spec.input_fn.steps_per_epoch(),\n",
")\n",
"\n",
"estimator = tf.estimator.Estimator(model_fn, config=config, params=params)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To obverse training, we can start TensorBoard (requires version 1.13 or later)."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# Load the TensorBoard notebook extension.\n",
"%load_ext tensorboard"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"%tensorboard --logdir ckpts-mnist-cnn"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let the training begin…"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:From /root/miniconda/envs/tfsurv/lib/python3.7/site-packages/tensorflow_core/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.\n",
"WARNING:tensorflow:From :142: DatasetV1.make_one_shot_iterator (from tensorflow.python.data.ops.dataset_ops) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use `for ... in dataset:` to iterate over a dataset. If using `tf.estimator`, return the `Dataset` object directly from your input function. As a last resort, you can use `tf.compat.v1.data.make_one_shot_iterator(dataset)`.\n",
"WARNING:tensorflow:From /root/miniconda/envs/tfsurv/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"If using Keras pass *_constraint arguments to layers.\n",
"WARNING:tensorflow:From :155: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
"WARNING:tensorflow:\n",
"The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
"For more information, please see:\n",
" * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
" * https://github.com/tensorflow/addons\n",
" * https://github.com/tensorflow/io (for I/O related ops)\n",
"If you depend on functionality not listed there, please file an issue.\n",
"\n",
"WARNING:tensorflow:From /root/miniconda/envs/tfsurv/lib/python3.7/site-packages/tensorflow_core/python/training/saver.py:1069: get_checkpoint_mtimes (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use standard file utilities to get mtimes.\n",
"WARNING:tensorflow:From /root/miniconda/envs/tfsurv/lib/python3.7/site-packages/tensorflow_core/python/training/saver.py:963: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use standard file APIs to delete files with this prefix.\n"
]
},
{
"data": {
"text/plain": [
"({'loss': 1.9082849, 'global_step': 14055}, [])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can make a couple of observations:\n",
"\n",
"1. The final concordance index on the validation data is close to the optimal value we computed above using the actual underlying risk scores.\n",
"2. The loss during training is quite volatile, which stems from the small batch size (64) and the varying number of uncensored samples that contribute to the loss in each batch. Increasing the batch size should yield smoother loss curves."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Predicting Survival Functions\n",
"\n",
"For inference, things are much easier, we just pass a batch of images and record the predicted risk score. To estimate individual survival functions, we need to estimate the baseline hazard function $h_0$, which can be done analogous to the linear Cox PH model by using [Breslow's estimator](https://www.jstor.org/stable/1402659)."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"from sksurv.linear_model.coxph import BreslowEstimator\n",
"\n",
"\n",
"def make_pred_fn(images: np.ndarray,\n",
" batch_size: int = 64):\n",
" if images.ndim == 3:\n",
" images = images[..., np.newaxis]\n",
"\n",
" def _input_fn():\n",
" ds = tf.data.Dataset.from_tensor_slices(images)\n",
" ds = ds.batch(batch_size)\n",
" next_x = ds.make_one_shot_iterator().get_next()\n",
" return next_x, None\n",
" return _input_fn\n",
"\n",
"\n",
"train_pred_fn = make_pred_fn(x_train)\n",
"train_predictions = np.array([float(pred[\"risk_score\"])\n",
" for pred in estimator.predict(train_pred_fn)])\n",
"\n",
"breslow = BreslowEstimator().fit(train_predictions, event_train, time_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Once fitted, we can use Breslow's estimator to obtain estimated survival functions for images in the test data. We randomly draw three sample images for each digit and plot their predicted survival function."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"sample = train_test_split(x_test, y_test, event_test, time_test,\n",
" test_size=30, stratify=y_test, random_state=89)\n",
"x_sample, y_sample, event_sample, time_sample = sample[1::2]\n",
"\n",
"sample_pred_fn = make_pred_fn(x_sample)\n",
"sample_predictions = np.array([float(pred[\"risk_score\"])\n",
" for pred in estimator.predict(sample_pred_fn)])\n",
"\n",
"sample_surv_fn = breslow.get_survival_function(sample_predictions)\n",
"\n",
"plt.figure(figsize=(6, 4.5))\n",
"for surv_fn, class_label in zip(sample_surv_fn, y_sample):\n",
" risk_group = risk_score_assignment.loc[class_label, \"risk_group\"]\n",
" plt.step(surv_fn.x, surv_fn.y, where=\"post\",\n",
" color=f\"C{class_label}\", linestyle=styles[risk_group])\n",
"\n",
"plt.ylim(0, 1)\n",
"plt.ylabel(\"Probability of survival $P(T > t)$\")\n",
"plt.xlabel(\"Time $t$\")\n",
"plt.grid()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Solid lines correspond to images that belong to risk group 0 (with lowest risk), which the model was able to learn. Samples from the group with the highest risk are shown as dotted lines. Their predicted survival functions have the steepest descent, confirming that the model correctly identified different risk groups from images."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Conclusion\n",
"\n",
"We successfully built, trained, and evaluated a convolutional neural network for survival analysis on MNIST. While MNIST is obviously not a clinical dataset, the exact same approach can be used for clinical data. For instance, [Mobadersany et al.](https://www.pnas.org/content/115/13/E2970) used the same approach to predict overall survival of patients diagnosed with brain tumors from microscopic images, and [Zhu et al.](https://scholar.google.com/scholar?cluster=3381426605939025516) applied CNNs to predict survival of lung cancer patients from pathological images."
]
}
],
"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.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}