{ "cells": [ { "cell_type": "markdown", "source": [ "In this notebook, we introduce survival analysis and we show application examples using both R and Python. We will compare the two programming languages, and leverage Plotly's Python and R APIs to convert static graphics into interactive `plotly` objects.\n", "\n", "[Plotly](https://plotly.com) is a platform for making interactive graphs with R, Python, MATLAB, and Excel. You can make graphs and analyze data on Plotly’s free public cloud. For collaboration and sensitive data, you can run Plotly [on your own servers](https://plotly.com/product/enterprise/).\n", "\n", "For a more in-depth theoretical background in survival analysis, please refer to these sources:\n", "\n", "- [Lecture Notes by John Fox](http://socserv.mcmaster.ca/jfox/Courses/soc761/survival-analysis.pdf)\n", "- [Wikipedia article](http://en.wikipedia.org/wiki/Survival_analysis)\n", "- [Presentation by Kristin Sainani](www.pitt.edu/~super4/33011-34001/33051-33061.ppt)\n", "- [Lecture Notes by Germán Rodríguez](http://data.princeton.edu/wws509/notes/c7.pdf)\n", "\n", "Need help converting Plotly graphs from R or Python?\n", "- [R](https://plotly.com/r/user-guide/)\n", "- [Python](https://plotly.com/python/matplotlib-to-plotly-tutorial/)\n", "\n", "For this code to run on your machine, you will need several R and Python packages installed.\n", "\n", "- Running `sudo pip install ` from your terminal will install a Python package.\n", "\n", "- Running `install.packages(\"\")` in your R console will install an R package.\n", "\n", "You will also need to create an account with [Plotly](https://plotly.com/feed/) to receive your API key." ], "metadata": {} }, { "cell_type": "code", "execution_count": 1, "source": [ "# You can also install packages from within IPython!\r\n", "\r\n", "# Install Python Packages\r\n", "!pip install lifelines\r\n", "!pip install rpy2\r\n", "!pip install plotly\r\n", "!pip install pandas\r\n", "\r\n", "# Load extension that let us use magic function `%R`\r\n", "%load_ext rpy2.ipython\r\n", "\r\n", "# Install R packages\r\n", "%R install.packages(\"devtools\")\r\n", "%R devtools::install_github(\"plotly/plotly.R\")\r\n", "%R install.packages(\"OIsurv\")" ], "outputs": [], "metadata": { "collapsed": true } }, { "cell_type": "markdown", "source": [ "## Introduction" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "[Survival analysis](http://en.wikipedia.org/wiki/Survival_analysis) is a set of statistical methods for analyzing the occurrence of events over time. It is also used to determine the relationship of co-variates to the time-to-events, and accurately compare time-to-event between two or more groups. For example:\n", "\n", "- Time to death in biological systems.\n", "- Failure time in mechanical systems.\n", "- How long can we expect a user to be on a website / service?\n", "- Time to recovery for lung cancer treatment.\n", "\n", "The statistical term 'survival analysis' is analogous to 'reliability theory' in engineering, 'duration analysis' in economics, and 'event history analysis' in sociology." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The two key functions in survival analysis are the *survival function* and the *hazard function*.\n", "\n", "The **survival function**, conventionally denoted by $S$, is the probability that the event (say, death) has not occurred yet:\n", "\n", "$$S(t) = Pr(T > t),$$\n", "\n", "where $T$ denotes the time of death and $Pr$ the probability. Since $S$ is a probability, $0\\leq S(t)\\leq1$. Survival times are non-negative ($T \\geq 0$) and, generally, $S(0) = 1$.\n", "\n", "\n", "The **hazard function** $h(t)$ is the event (death) rate at time $t$, conditional on survival until $t$ (i.e., $T \\geq t$):\n", "\n", "\\begin{align*}\n", "h(t) &= \\lim_{\\Delta t \\to 0} Pr(t \\leq T \\leq t + \\Delta t \\, | \\, T \\geq t) \\\\\n", " &= \\lim_{\\Delta t \\to 0} \\frac{Pr(t \\leq T \\leq t + \\Delta t)}{S(t)} = \\frac{p(t)}{S(t)},\n", "\\end{align*}\n", "\n", "where $p$ denotes the probability density function.\n", "\n", "In practice, we do not get to observe the actual survival function of a population; we must use the observed data to estimate it. A popular estimate for the survival function $S(t)$ is the [Kaplan–Meier estimate](http://en.wikipedia.org/wiki/Kaplan–Meier_estimator):\n", "\n", "\\begin{align*}\n", "\\hat{S}(t) &= \\prod_{t_i \\leq t} \\frac{n_i − d_i}{n_i}\\,,\n", "\\end{align*}\n", "\n", "where $d_i$ is the number of events (deaths) observed at time $t_i$ and $n_i$ is the number of subjects at risk observed at time $t_i$." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Censoring" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Censoring is a type of missing data problem common in survival analysis. Other popular comparison methods, such as linear regression and t-tests do not accommodate for censoring. This makes survival analysis attractive for data from randomized clinical studies. \n", "\n", "In an ideal scenario, both the birth and death rates of a patient is known, which means the lifetime is known.\n", "\n", "**Right censoring** occurs when the 'death' is unknown, but it is after some known date. e.g. The 'death' occurs after the end of the study, or there was no follow-up with the patient.\n", "\n", "**Left censoring** occurs when the lifetime is known to be less than a certain duration. e.g. Unknown time of initial infection exposure when first meeting with a patient.\n", "\n", "
" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "For following analysis, we will use the [lifelines](https://github.com/CamDavidsonPilon/lifelines) library for python, and the [survival](http://cran.r-project.org/web/packages/survival/survival.pdf) package for R. We can use [rpy2](http://rpy.sourceforge.net) to execute R code in the same document as the python code.\n", "\n" ], "metadata": {} }, { "cell_type": "code", "execution_count": 2, "source": [ "# OIserve contains the survival package and sample datasets\n", "%R library(OIsurv)\n", "%R library(devtools)\n", "%R library(plotly)\n", "%R library(IRdisplay)\n", "\n", "# Authenticate to plotly's api using your account\n", "%R py <- plotly(\"rmdk\", \"0sn825k4r8\")\n", "\n", "# Load python libraries\n", "import numpy as np\n", "import pandas as pd\n", "import lifelines as ll\n", "\n", "# Plotting helpers\n", "from IPython.display import HTML\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import plotly.plotly as py\n", "import plotly.tools as tls \n", "from plotly.graph_objs import *\n", "\n", "from pylab import rcParams\n", "rcParams['figure.figsize']=10, 5" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "Loading required package: survival\n", "Loading required package: KMsurv\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "Loading required package: RCurl\n", "Loading required package: bitops\n", "Loading required package: RJSONIO\n", "Loading required package: ggplot2\n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Loading data into Python and R\n", "\n", "We will be using the `tongue` dataset from the `KMsurv` package in R, then convert the data into a pandas dataframe under the same name.\n", "\n", "\n", "This data frame contains the following columns:\n", "\n", "- type: Tumor DNA profile (1=Aneuploid Tumor, 2=Diploid Tumor) \n", "- time: Time to death or on-study time, weeks\n", "- delta Death indicator (0=alive, 1=dead)" ], "metadata": {} }, { "cell_type": "code", "execution_count": 3, "source": [ "# Load in data\n", "%R data(tongue)\n", "# Pull data into python kernel\n", "%Rpull tongue\n", "# Convert into pandas dataframe\n", "from rpy2.robjects import pandas2ri\n", "\n", "tongue = pandas2ri.ri2py_dataframe(tongue)" ], "outputs": [], "metadata": { "collapsed": true } }, { "cell_type": "markdown", "source": [ "We can now refer to `tongue` using both R and python." ], "metadata": {} }, { "cell_type": "code", "execution_count": 4, "source": [ "%%R \n", "summary(tongue)" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ " type time delta \n", " Min. :1.00 Min. : 1.00 Min. :0.0000 \n", " 1st Qu.:1.00 1st Qu.: 23.75 1st Qu.:0.0000 \n", " Median :1.00 Median : 69.50 Median :1.0000 \n", " Mean :1.35 Mean : 73.83 Mean :0.6625 \n", " 3rd Qu.:2.00 3rd Qu.:101.75 3rd Qu.:1.0000 \n", " Max. :2.00 Max. :400.00 Max. :1.0000 \n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "code", "execution_count": 5, "source": [ "tongue.describe()" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
typetimedelta
count80.00000080.00000080.00000
mean1.35000073.8250000.66250
std0.47997967.2630910.47584
min1.0000001.0000000.00000
25%1.00000023.7500000.00000
50%1.00000069.5000001.00000
75%2.000000101.7500001.00000
max2.000000400.0000001.00000
\n", "
" ], "text/plain": [ " type time delta\n", "count 80.000000 80.000000 80.00000\n", "mean 1.350000 73.825000 0.66250\n", "std 0.479979 67.263091 0.47584\n", "min 1.000000 1.000000 0.00000\n", "25% 1.000000 23.750000 0.00000\n", "50% 1.000000 69.500000 1.00000\n", "75% 2.000000 101.750000 1.00000\n", "max 2.000000 400.000000 1.00000" ] }, "metadata": {}, "execution_count": 5 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We can even operate on R and Python within the same code cell." ], "metadata": {} }, { "cell_type": "code", "execution_count": 6, "source": [ "%R print(mean(tongue$time))\n", "\n", "print tongue['time'].mean()" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "[1] 73.825\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "73.825\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "In R we need to create a `Surv` object with the `Surv()` function. Most functions in the `survival` package apply methods to this object. For right-censored data, we need to pass two arguments to `Surv()`:\n", "\n", "1. a vector of times\n", "2. a vector indicating which times are observed and censored" ], "metadata": {} }, { "cell_type": "code", "execution_count": 7, "source": [ "%%R\n", "attach(tongue)\n", "\n", "tongue.surv <- Surv(time[type==1], delta[type==1])\n", "\n", "tongue.surv" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ " [1] 1 3 3 4 10 13 13 16 16 24 26 27 28 30 30 \n", "[16] 32 41 51 65 67 70 72 73 77 91 93 96 100 104 157 \n", "[31] 167 61+ 74+ 79+ 80+ 81+ 87+ 87+ 88+ 89+ 93+ 97+ 101+ 104+ 108+\n", "[46] 109+ 120+ 131+ 150+ 231+ 240+ 400+\n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "- The plus-signs identify observations that are right-censored." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "# Estimating survival with Kaplan-Meier\n", "\n", "### Using R" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The simplest fit estimates a survival object against an intercept. However, the `survfit()` function has several optional arguments. For example, we can change the confidence interval using `conf.int` and `conf.type`. \n", "\n", "See `help(survfit.formula)` for the comprehensive documentation." ], "metadata": {} }, { "cell_type": "code", "execution_count": 8, "source": [ "%%R\n", "surv.fit <- survfit(tongue.surv~1)\n", "surv.fit" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "Call: survfit(formula = tongue.surv ~ 1)\n", "\n", "records n.max n.start events median 0.95LCL 0.95UCL \n", " 52 52 52 31 93 67 NA \n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "It is often helpful to call the `summary()` and `plot()` functions on this object." ], "metadata": {} }, { "cell_type": "code", "execution_count": 9, "source": [ "%%R \n", "summary(surv.fit)" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "Call: survfit(formula = tongue.surv ~ 1)\n", "\n", " time n.risk n.event survival std.err lower 95% CI upper 95% CI\n", " 1 52 1 0.981 0.0190 0.944 1.000\n", " 3 51 2 0.942 0.0323 0.881 1.000\n", " 4 49 1 0.923 0.0370 0.853 0.998\n", " 10 48 1 0.904 0.0409 0.827 0.988\n", " 13 47 2 0.865 0.0473 0.777 0.963\n", " 16 45 2 0.827 0.0525 0.730 0.936\n", " 24 43 1 0.808 0.0547 0.707 0.922\n", " 26 42 1 0.788 0.0566 0.685 0.908\n", " 27 41 1 0.769 0.0584 0.663 0.893\n", " 28 40 1 0.750 0.0600 0.641 0.877\n", " 30 39 2 0.712 0.0628 0.598 0.846\n", " 32 37 1 0.692 0.0640 0.578 0.830\n", " 41 36 1 0.673 0.0651 0.557 0.813\n", " 51 35 1 0.654 0.0660 0.537 0.797\n", " 65 33 1 0.634 0.0669 0.516 0.780\n", " 67 32 1 0.614 0.0677 0.495 0.762\n", " 70 31 1 0.594 0.0683 0.475 0.745\n", " 72 30 1 0.575 0.0689 0.454 0.727\n", " 73 29 1 0.555 0.0693 0.434 0.709\n", " 77 27 1 0.534 0.0697 0.414 0.690\n", " 91 19 1 0.506 0.0715 0.384 0.667\n", " 93 18 1 0.478 0.0728 0.355 0.644\n", " 96 16 1 0.448 0.0741 0.324 0.620\n", " 100 14 1 0.416 0.0754 0.292 0.594\n", " 104 12 1 0.381 0.0767 0.257 0.566\n", " 157 5 1 0.305 0.0918 0.169 0.550\n", " 167 4 1 0.229 0.0954 0.101 0.518\n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "code", "execution_count": 10, "source": [ "%%R -h 400\n", "plot(surv.fit, main='Kaplan-Meier estimate with 95% confidence bounds',\n", " xlab='time', ylab='survival function')" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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" }, "metadata": {} } ], "metadata": { "scrolled": true } }, { "cell_type": "markdown", "source": [ "Let's convert this plot into an interactive plotly object using [plotly](https://plotly.com) and [ggplot2](http://ggplot2.org). \n", "\n", "First, we will use a helper ggplot function written by [Edwin Thoen](http://www.r-statistics.com/2013/07/creating-good-looking-survival-curves-the-ggsurv-function/) to plot pretty survival distributions in R. " ], "metadata": {} }, { "cell_type": "code", "execution_count": 11, "source": [ "%%R\n", "\n", "ggsurv <- function(s, CI = 'def', plot.cens = T, surv.col = 'gg.def',\n", " cens.col = 'red', lty.est = 1, lty.ci = 2,\n", " cens.shape = 3, back.white = F, xlab = 'Time',\n", " ylab = 'Survival', main = ''){\n", " \n", " library(ggplot2)\n", " strata <- ifelse(is.null(s$strata) ==T, 1, length(s$strata))\n", " stopifnot(length(surv.col) == 1 | length(surv.col) == strata)\n", " stopifnot(length(lty.est) == 1 | length(lty.est) == strata)\n", " \n", " ggsurv.s <- function(s, CI = 'def', plot.cens = T, surv.col = 'gg.def',\n", " cens.col = 'red', lty.est = 1, lty.ci = 2,\n", " cens.shape = 3, back.white = F, xlab = 'Time',\n", " ylab = 'Survival', main = ''){\n", " \n", " dat <- data.frame(time = c(0, s$time),\n", " surv = c(1, s$surv),\n", " up = c(1, s$upper),\n", " low = c(1, s$lower),\n", " cens = c(0, s$n.censor))\n", " dat.cens <- subset(dat, cens != 0)\n", " \n", " col <- ifelse(surv.col == 'gg.def', 'black', surv.col)\n", " \n", " pl <- ggplot(dat, aes(x = time, y = surv)) +\n", " xlab(xlab) + ylab(ylab) + ggtitle(main) +\n", " geom_step(col = col, lty = lty.est)\n", " \n", " pl <- if(CI == T | CI == 'def') {\n", " pl + geom_step(aes(y = up), color = col, lty = lty.ci) +\n", " geom_step(aes(y = low), color = col, lty = lty.ci)\n", " } else (pl)\n", " \n", " pl <- if(plot.cens == T & length(dat.cens) > 0){\n", " pl + geom_point(data = dat.cens, aes(y = surv), shape = cens.shape,\n", " col = cens.col)\n", " } else if (plot.cens == T & length(dat.cens) == 0){\n", " stop ('There are no censored observations')\n", " } else(pl)\n", " \n", " pl <- if(back.white == T) {pl + theme_bw()\n", " } else (pl)\n", " pl\n", " }\n", " \n", " ggsurv.m <- function(s, CI = 'def', plot.cens = T, surv.col = 'gg.def',\n", " cens.col = 'red', lty.est = 1, lty.ci = 2,\n", " cens.shape = 3, back.white = F, xlab = 'Time',\n", " ylab = 'Survival', main = '') {\n", " n <- s$strata\n", " \n", " groups <- factor(unlist(strsplit(names\n", " (s$strata), '='))[seq(2, 2*strata, by = 2)])\n", " gr.name <- unlist(strsplit(names(s$strata), '='))[1]\n", " gr.df <- vector('list', strata)\n", " ind <- vector('list', strata)\n", " n.ind <- c(0,n); n.ind <- cumsum(n.ind)\n", " for(i in 1:strata) ind[[i]] <- (n.ind[i]+1):n.ind[i+1]\n", " \n", " for(i in 1:strata){\n", " gr.df[[i]] <- data.frame(\n", " time = c(0, s$time[ ind[[i]] ]),\n", " surv = c(1, s$surv[ ind[[i]] ]),\n", " up = c(1, s$upper[ ind[[i]] ]),\n", " low = c(1, s$lower[ ind[[i]] ]),\n", " cens = c(0, s$n.censor[ ind[[i]] ]),\n", " group = rep(groups[i], n[i] + 1))\n", " }\n", " \n", " dat <- do.call(rbind, gr.df)\n", " dat.cens <- subset(dat, cens != 0)\n", " \n", " pl <- ggplot(dat, aes(x = time, y = surv, group = group)) +\n", " xlab(xlab) + ylab(ylab) + ggtitle(main) +\n", " geom_step(aes(col = group, lty = group))\n", " \n", " col <- if(length(surv.col == 1)){\n", " scale_colour_manual(name = gr.name, values = rep(surv.col, strata))\n", " } else{\n", " scale_colour_manual(name = gr.name, values = surv.col)\n", " }\n", " \n", " pl <- if(surv.col[1] != 'gg.def'){\n", " pl + col\n", " } else {pl + scale_colour_discrete(name = gr.name)}\n", " \n", " line <- if(length(lty.est) == 1){\n", " scale_linetype_manual(name = gr.name, values = rep(lty.est, strata))\n", " } else {scale_linetype_manual(name = gr.name, values = lty.est)}\n", " \n", " pl <- pl + line\n", " \n", " pl <- if(CI == T) {\n", " if(length(surv.col) > 1 && length(lty.est) > 1){\n", " stop('Either surv.col or lty.est should be of length 1 in order\n", " to plot 95% CI with multiple strata')\n", " }else if((length(surv.col) > 1 | surv.col == 'gg.def')[1]){\n", " pl + geom_step(aes(y = up, color = group), lty = lty.ci) +\n", " geom_step(aes(y = low, color = group), lty = lty.ci)\n", " } else{pl + geom_step(aes(y = up, lty = group), col = surv.col) +\n", " geom_step(aes(y = low,lty = group), col = surv.col)}\n", " } else {pl}\n", " \n", " \n", " pl <- if(plot.cens == T & length(dat.cens) > 0){\n", " pl + geom_point(data = dat.cens, aes(y = surv), shape = cens.shape,\n", " col = cens.col)\n", " } else if (plot.cens == T & length(dat.cens) == 0){\n", " stop ('There are no censored observations')\n", " } else(pl)\n", " \n", " pl <- if(back.white == T) {pl + theme_bw()\n", " } else (pl)\n", " pl\n", " }\n", " pl <- if(strata == 1) {ggsurv.s(s, CI , plot.cens, surv.col ,\n", " cens.col, lty.est, lty.ci,\n", " cens.shape, back.white, xlab,\n", " ylab, main)\n", " } else {ggsurv.m(s, CI, plot.cens, surv.col ,\n", " cens.col, lty.est, lty.ci,\n", " cens.shape, back.white, xlab,\n", " ylab, main)}\n", " pl\n", "}" ], "outputs": [], "metadata": { "collapsed": true } }, { "cell_type": "markdown", "source": [ "Voila!" ], "metadata": {} }, { "cell_type": "code", "execution_count": 12, "source": [ "%%R -h 400\n", "p <- ggsurv(surv.fit) + theme_bw()\n", "p" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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" }, "metadata": {} } ], "metadata": { "scrolled": true } }, { "cell_type": "markdown", "source": [ "We have to use a workaround to render an interactive plotly object by using an iframe in the ipython kernel. This is a bit easier if you are working in an R kernel." ], "metadata": {} }, { "cell_type": "code", "execution_count": 13, "source": [ "%%R\n", "# Create the iframe HTML\n", "plot.ly <- function(url) {\n", " # Set width and height from options or default square\n", " w <- \"750\"\n", " h <- \"600\"\n", " html <- paste(\"
\", sep=\"\")\n", " return(html)\n", "}" ], "outputs": [], "metadata": { "collapsed": true } }, { "cell_type": "code", "execution_count": 14, "source": [ "%R p <- plot.ly(\"https://plotly.com/~rmdk/111/survival-vs-time/\")\n", "# pass object to python kernel\n", "%R -o p \n", "\n", "# Render HTML\n", "HTML(p[0])" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 14 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "The `y axis` represents the probability a patient is still alive at time $t$ weeks. We see a steep drop off within the first 100 weeks, and then observe the curve flattening. The dotted lines represent the 95% confidence intervals." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Using Python" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We will now replicate the above steps using python. Above, we have already specified a variable `tongues` that holds the data in a pandas dataframe." ], "metadata": {} }, { "cell_type": "code", "execution_count": 15, "source": [ "from lifelines.estimation import KaplanMeierFitter\n", "kmf = KaplanMeierFitter()" ], "outputs": [], "metadata": { "collapsed": true } }, { "cell_type": "markdown", "source": [ "The method takes the same parameters as it's R counterpart, a time vector and a vector indicating which observations are observed or censored. The model fitting sequence is similar to the [scikit-learn](http://scikit-learn.org/stable/) api." ], "metadata": {} }, { "cell_type": "code", "execution_count": 16, "source": [ "f = tongue.type==1\n", "T = tongue[f]['time']\n", "C = tongue[f]['delta']\n", "\n", "kmf.fit(T, event_observed=C)" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 16 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "To get a plot with the confidence intervals, we simply can call `plot()` on our `kmf` object." ], "metadata": {} }, { "cell_type": "code", "execution_count": 17, "source": [ "kmf.plot(title='Tumor DNA Profile 1')" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 17 }, { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {} } ], "metadata": { "scrolled": true } }, { "cell_type": "markdown", "source": [ "Now we can convert this plot to an interactive [Plotly](https://plotly.com) object. However, we will have to augment the legend and filled area manually. Once we create a helper function, the process is simple.\n", "\n", "Please see the Plotly Python [user guide](https://plotly.com/python/overview/#in-%5B37%5D) for more insight on how to update plot parameters. \n", "\n", "> Don't forget you can also easily edit the chart properties using the Plotly GUI interface by clicking the \"Play with this data!\" link below the chart." ], "metadata": {} }, { "cell_type": "code", "execution_count": 19, "source": [ "p = kmf.plot(ci_force_lines=True, title='Tumor DNA Profile 1 (95% CI)')\n", "\n", "# Collect the plot object\n", "kmf1 = plt.gcf() \n", "\n", "def pyplot(fig, ci=True, legend=True):\n", " # Convert mpl fig obj to plotly fig obj, resize to plotly's default\n", " py_fig = tls.mpl_to_plotly(fig, resize=True)\n", " \n", " # Add fill property to lower limit line\n", " if ci == True:\n", " style1 = dict(fill='tonexty')\n", " # apply style\n", " py_fig['data'][2].update(style1)\n", " \n", " # Change color scheme to black\n", " py_fig['data'].update(dict(line=Line(color='black')))\n", " \n", " # change the default line type to 'step'\n", " py_fig['data'].update(dict(line=Line(shape='hv')))\n", " # Delete misplaced legend annotations \n", " py_fig['layout'].pop('annotations', None)\n", " \n", " if legend == True:\n", " # Add legend, place it at the top right corner of the plot\n", " py_fig['layout'].update(\n", " showlegend=True,\n", " legend=Legend(\n", " x=1.05,\n", " y=1\n", " )\n", " )\n", " \n", " # Send updated figure object to Plotly, show result in notebook\n", " return py.iplot(py_fig)\n", "\n", "pyplot(kmf1, legend=False)" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 19 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "
\n", "# Multiple Types\n", "\n", "### Using R" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Many times there are different groups contained in a single dataset. These may represent categories such as treatment groups, different species, or different manufacturing techniques. The `type` variable in the `tongues` dataset describes a patients DNA profile. Below we define a Kaplan-Meier estimate for each of these groups in R and Python." ], "metadata": {} }, { "cell_type": "code", "execution_count": 19, "source": [ "%%R\n", "\n", "surv.fit2 <- survfit( Surv(time, delta) ~ type)\n", "\n", "p <- ggsurv(surv.fit2) + \n", " ggtitle('Lifespans of different tumor DNA profile') + theme_bw()\n", "p" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAHgCAYAAAB91L6VAAAD8GlDQ1BJQ0MgUHJvZmlsZQAAOI2NVd1v21QUP4lvXKQWP6Cxjg4Vi69VU1u5GxqtxgZJk6XpQhq5zdgqpMl1bhpT1za2021Vn/YCbwz4A4CyBx6QeEIaDMT2su0BtElTQRXVJKQ9dNpAaJP2gqpwrq9Tu13GuJGvfznndz7v0TVAx1ea45hJGWDe8l01n5GPn5iWO1YhCc9BJ/RAp6Z7TrpcLgIuxoVH1sNfIcHeNwfa6/9zdVappwMknkJsVz19HvFpgJSpO64PIN5G+fAp30Hc8TziHS4miFhheJbjLMMzHB8POFPqKGKWi6TXtSriJcT9MzH5bAzzHIK1I08t6hq6zHpRdu2aYdJYuk9Q/881bzZa8Xrx6fLmJo/iu4/VXnfH1BB/rmu5ScQvI77m+BkmfxXxvcZcJY14L0DymZp7pML5yTcW61PvIN6JuGr4halQvmjNlCa4bXJ5zj6qhpxrujeKPYMXEd+q00KR5yNAlWZzrF+Ie+uNsdC/MO4tTOZafhbroyXuR3Df08bLiHsQf+ja6gTPWVimZl7l/oUrjl8OcxDWLbNU5D6JRL2gxkDu16fGuC054OMhclsyXTOOFEL+kmMGs4i5kfNuQ62EnBuam8tzP+Q+tSqhz9SuqpZlvR1EfBiOJTSgYMMM7jpYsAEyqJCHDL4dcFFTAwNMlFDUUpQYiadhDmXteeWAw3HEmA2s15k1RmnP4RHuhBybdBOF7MfnICmSQ2SYjIBM3iRvkcMki9IRcnDTthyLz2Ld2fTzPjTQK+Mdg8y5nkZfFO+se9LQr3/09xZr+5GcaSufeAfAww60mAPx+q8u/bAr8rFCLrx7s+vqEkw8qb+p26n11Aruq6m1iJH6PbWGv1VIY25mkNE8PkaQhxfLIF7DZXx80HD/A3l2jLclYs061xNpWCfoB6WHJTjbH0mV35Q/lRXlC+W8cndbl9t2SfhU+Fb4UfhO+F74GWThknBZ+Em4InwjXIyd1ePnY/Psg3pb1TJNu15TMKWMtFt6ScpKL0ivSMXIn9QtDUlj0h7U7N48t3i8eC0GnMC91dX2sTivgloDTgUVeEGHLTizbf5Da9JLhkhh29QOs1luMcScmBXTIIt7xRFxSBxnuJWfuAd1I7jntkyd/pgKaIwVr3MgmDo2q8x6IdB5QH162mcX7ajtnHGN2bov71OU1+U0fqqoXLD0wX5ZM005UHmySz3qLtDqILDvIL+iH6jB9y2x83ok898GOPQX3lk3Itl0A+BrD6D7tUjWh3fis58BXDigN9yF8M5PJH4B8Gr79/F/XRm8m241mw/wvur4BGDj42bzn+Vmc+NL9L8GcMn8F1kAcXgSteGGAABAAElEQVR4Ae3dB7wU1dnA4Xf37uXSe5FibxRBsSA2VBQLlkSjsUWMsRBN1GhiCZZY+Cwxdo2FWJIYoygmGltAqQoSGyoCFooKSJcOt+zOd94Ds+7du3u3787u/g+/ZXfKOXPmmbnzzpnqc0wSEgIIIIAAAgjkVcCf16kxMQQQQAABBBCwAgRgVgQEEEAAAQQKIEAALgA6k0QAAQQQQIAAzDqAAAIIIIBAAQQIwAVAZ5IIIIAAAggQgFkHEEAAAQQQKIAAAbgA6EwSAQQQQAABAjDrAAIIIIAAAgUQIAAXAJ1JIoAAAgggQABmHUAAAQQQQKAAAgTgAqAzSQQQQAABBAjArAMIIIAAAggUQIAAXAB0JokAAggggAABmHUAAQQQQACBAggQgAuAziQRQAABBBAgALMOIIAAAgggUAABAnAB0JkkAggggAACFTeaBIO3BWbMmCFz586V7bbbLmZFp0+fLmvWrJHOnTvb4TNnzpTnnntOFi1aJL169YqZpxR7hkIhef311+U///mPtGjRQrp06dLobC5btkwmTJggu+22mwSDQXnllVesYbNmzSS6rE6dOqVUdqMTzmCg4zji8/nilpBoeNyMeRjw/fffy7hx4+Tzzz+3H12ntV/r1q2lqqqqXg10Hf7ggw9k1113rddfO9555x1Zt25deH13R9Dy3n77bdl2222lsrLS7Z2378h1pmnTpvLee++F16epU6fKhg0bpGPHjnmrDxMqAgHzB0vyuMB5553nHHrooXFrOXToUOfyyy+3wz/77DPHbMycvffe27n++uvj5inFAbfffrud9yOPPNL573//m3AWX331VcdsKO1469evd8yfqzNt2jTbHV1WdHfCwnMwwh133OH8+c9/jltyouFxM+ZpgNqqsQlCjtk5ctq2bWu79fuPf/xjvVpceumldthf//rXev21Y9CgQc4VV1zRoP9xxx3nBAIB55FHHmkwLB89IteRl156qd76dPjhhzsjRozIRzWYRhEJcAi6CHaSElVx1KhRYv647WjaGtbW3/vvvy8333xzoqwlNXzixIkybNgw28o66qijUpq35s2byxdffCF77bWXzRddVnR3SoVnaeR//OMfUl1dHbe0RMPjZszzABOIZcmSJbb1u3btWjHBVq666ir597//3aAml112mSxevLhB/+geOo7Z6RId/+GHH44enJfuyHXkhBNOqLc+5aUCTKToBDgEXQSL7OWXX5ZVq1bJz3/+85i11Q2Pbsi++eYbeeqpp+yhZ7MTKF27dpX27dvL119/LablJM8++6zdmPXr108qKipsWbpBf+KJJ+Qvf/mL/O9//xM9/NqjRw877NNPP5U333xTtKx77rnHHhLUQ7GRh9FWrlwpugPw97//3R7+03F33nnncP633nrLlvnggw/aDaweGtxpp53C8zF+/Hh54IEH7OHdFStWyB577NHoIVbTahXTwhEtVw/FumU9+uijok46fS3nwAMPDE/D/aGHCPUws+b/8ssv7Y7KmDFj5LrrrpO6ujrroIejn3nmmXplqUOssrXuurEfO3asmJaX7LjjjnZSanrXXXdZ/9tuu02+++67cGCPl6empkb+9Kc/Se/eveXJJ5+0y/Hbb7+VPffc0y6rf/7zn/Liiy/aAKyGffr0cWfLfkcPV5e7777bHl7XHTJN8+bNk8cff9zauNPr2bOnnW8N3mqw++67y6RJk+wyWbp0qV2WTZo0sfn1v3j+jc2zm3nhwoV2+hpwdb3UpIeeTetQFixYILqOmJat7f/GG29YU51XPax85pln2v7631NmHe/WrZscffTR4X6aV+ur69I111wjugOmh6Ljpeeff142bdpky9Z1R09H6PLTQ8ea9BRObW2tXRd0mely0Z20ePMfvf7tt99+4fWpVatWYlrytj5HHHGELb+xv0k7Av+VhQAt4BJYzLrB1sCiG0H9aKDRc2S6QdWgqhtxPffWpk0bueGGG8QcwrMbF531c8891260dIOmGyEdpmVp0nNYv/3tb+3GTAObnnvbZ599RAOSJj3HrIFAN5bdu3e35/WOOeYY0WCgSfP//ve/F+2n42qrZ8iQITaY6XANKCeddJL+tHXTVvz5559vu2P9pxvnk08+2e6M6Mb82GOPFXOY3Y6q59f0PK4GFnM4OVZ2W5czzjjD+ujOyC9/+cvweJpPN9y6ExNdVnS3ZrrlllvkxBNPFN0BWb58ua2LOQRpy9MNu5b1k5/8RPSIhAboRHnc6WtQ0XPYGgjUw5x+CJepy1WXr5YfnbRf5HCts9ZBg7+b5syZI9dee63tdKeny0PPtep86LK48MIL5aKLLhK/3y833XSTXHzxxW52Gxzj+ceb53DmBD8OO+wwu47oOugmNdBgq+uXfjeW9G9Ag7TuPGpA152sxpLudJ5++unWQ6+dGDlypF2G6qJJd0jPPvtsG0RfeOEF2y+V9c/11fUpOiX6m4wen+4SFjAbVpLHBVI5B/zQQw85plUTnqOBAwc6ZsMa7t64caNjWh+OabnZfmbv3DF7++Hh999/v/Ovf/3LdpvWkj2PZS5sCg8/9dRT7Tk47WFaj86PfvQjxwT68HA9V33OOefYbjf/J598Eh5uWgDh4b/4xS+cU045JTxsypQpjtlBCHdH/vjoo48c0+J19Nyam55++mnHtOQdE1hsL7MRj3veW8+Nmz9jx7To3eyOusY7BxxdVmS3udjHnms0OxrhssxOiz3/bHY0HHNhkZ2WCYDh4YnymB0mmyfyvL2eyzStrnAZ5siFY45EhLujf0QONzsFtjxzAV94ND3nbVqzttud3tVXXx0ebo4aWA89H65J56ldu3Z2+SbyjzXP4YK3/nDPAZujD9GDHLNTZ+trWt92mJ4D1nVFk9mJc8zOo2N2umx39DlgzWN2GMLD//a3v9n5MDsVdvxY/5mdQvt3YAKlHax/F+boj2Na0LZbryPQvyPTCrbdieZfR4pcR6KvKYg8B5zob9JOkP/KQoAWcAnvXGlryT2srIdE9aOHorW1q1dlajIB1LaCTzvtNNvK0Bbij3/847CKHnbTFoWbtIWmLSZtbWlrSA/hfvzxx2KCoW2xzZ8/v14LzWzApW/fvm522WWXXWzrXHvoeTJtBR988MGirUdzMY5tdYVHjvih86EtIm2xuclcdGMPQ7/77rtur7jfWmc9vK7TcpMJ/u7PlL51ejr/Oq+uqx4V0EOWOh03mZ0R96ckm0ePQLhJrwA2gcG27N1+2f4+5JBDwkXq4Wits3vIWk9h6FXKenojWf/IeQ4XnMSPzZs327F0fYtOeqOGtmwvuOCC6EG2W1uzeupCD2PrURq9+l2P/miruLGk65J7tbSuG2qvR23cdMABB9jD4Nqd7Py7eeN9J/M3GS8v/UtPIFB6s8QcuQJ63lgDhR6O/Oqrr9zeNgi5tyfpob3Bgwfb87O/+tWvZPjw4fbwnR6a1qS3PkXeIqLBWw836gZTz2NpENRDvnrOVYNb9G0jev4rMum5Uq2TJg30ptVrz4/pjoEertbDtnr+zT1H7ebV87rbbLONDaJuPz2krgHe3Xi7/WN962FiPdQYOS+60U0naV20nOjDi3r4VuvjJj1f7qZk8+gtOW5yDUxTwO2V8ndkXg1K0SnyfL4Oc8/N6m89DO2mZP0j59nNm8y33pqkyT2nH5lHz0HreqoBUYNtZNJTLXo+V93OOuus8CBd7/S8rB42jnfblp7vjky6but8usm9rU+7k51/N2+872T+JuPlpX/pCRCAS2+ZhudIA5a2KPQcsJ7Pc5Oek9Rh2rrS840a9DTgavcll1wi2uJwA7BuGPXiFveeWr34SS9U0nL1fKJeuKLlucHitddeCwdYd3rxvvWqUW316oZSA4VeBautam1FDhgwoF42vbBLW5x6r6d7kZfeH62B1b1yuV6GqA4dR3cYIvPr9NNJGiR0J+TXv/51+GIo3QnQ+msrMlZKJ0+scpLt5144pTtfbtL5j07xglP0eJn6R5cX2a07ZHrBmDnsW28HIHKcfffdV8zhchtQIwOj7qzpPOgOptty13x6pbXuFOr6quXGStHLX8c1p09ijWrXuUzWP7fQRH+T7nh8l4fAD7u45TG/RTuXehhQL+iJ/LgXQ8WbKd0w6UU82mrQKzk1yGmA1Farthz0kO6tt95qL8zS4KvD9RBZ5AM/tJ9ecKQP+tCrUbW14W6ktLWkgUdbVjqeXj08efLkpFqkWmcdVy900QuqNOm0tc7uVdi259b/tM7aQtGLyHR8Pdyo9dLAoFd1J0r777+/PfytOyLamvnwww9Fr/xNJ+kGXXc8dAfEPeT+u9/9ztatZcuWMYtMJ090QeqtF1LpBVOxUuRwbQFqoNKWoy4jvcXKnN+PlS2pfpn6R05ET1noeqxHP3Sd0dMaWj+9YryxpMter2zWK9jdpFd168VjkcFXh2lrWY/yNHZLkgZp98pyvXpa1wtzjYNbdL3vbM1/or/JehOlo+QFCMBFsojNRSBiLt6o99HztYmSBli9JUM3crpRNg/ssLe7HHTQQfYQo7loy94zrC3cDh06yKxZs+ytIm65uhHXYKfnA80DP+zGTq+u1aRBRwOvHnbU8UaPHm3PA5uLrmx/t4x433qFtR4G1ACqLWE9BK63M2mgjU4a2PRWIC1bW5O6cdXWr+5YJHMoWTfQenW3PmFJN+J67lPPQaeTdMfFXAwmepuQntNWO3ORl5iLf8K3sUSXm06e6DL0fL3uTLm3sjQ2XDf0eljfPTyr86ve6aZM/SOnq+fedV3Wawv0/l89laC3Pmkrt7HkHorW0xiaZs+ebc+t605crGQu8rPrTLz7iPV89W9+8xu77mkLXK/ej7xeIbLMbM5/Y3+TkdPkd+kL+MwGNP0TTKXvUzJzqLdF6B5+rOCmM6ktbL2NJ/Icpm7stcWohy412OmG0j20GQmjwzTAxbqAJnK8eL91unqLkt7KlEzS6WlAiz6/nExeHUdvddH5dC/ASTZfrPH0IiU9V6o2yaZ08rhl61ECPWQbb6cjerja6q1IaqtBORspU/9s1CHTMvQWNr2F7s4777Q+8f4uYk0nW/Of6G8y1rTpV1oCW3YlS2uemJsYAho4G9vIRF78EyO7beXG6q/90r3wxi1Pzx8nG3yzMb3Ic4huHdL9jtxhSbaMdPK4ZUdeROb2i/yOHq62sQ7pR+ZJ9XemyzvV6eVyfN0paezvIta0szX/if4mY02bfqUlUPQBWBvwyVwFW+yLTeczWy2YZC10Y64bb73gqJRSISxLyc+dl2J21CCqRy28sm4Xs6W7PiTzrduUyKvrk8lTyuMU/SFofcKSXsyjVxemmzSA6yFNLyc9lKgrbr6DcComekhNz895+Q9MN3R6CNe9ajuV+cvnuMWyTur66OXlrctaLxKMdeokn8uzsWmVyzqpp5n0WoRsH5FpzNbrw4q+BazAehFP9LNxU4HX85+JDsGmUl4uxtXgpucsvRyA9ZYX3cN1L5LJhUOmZeoGWXdmsnH+N9O6NJa/GNZJffCIBl8v78xo8NXz4tFXSTdmn+9hGoDV0ss7CWqS6TqpF3iS6gtwFXR9D7oQQAABBBDIiwABOC/MTAQBBBBAAIH6AgTg+h50IYAAAgggkBcBAnBemJkIAggggAAC9QUIwPU96EIAAQQQQCAvAgTgvDAzEQQQQAABBOoLEIDre9CFAAIIIIBAXgQIwHlhZiIIIIAAAgjUFyAA1/egCwEEEEAAgbwIEIDzwsxEEEAAAQQQqC9AAK7vQRcCCCCAAAJ5ESAA54WZiSCAAAIIIFBfgABc34MuBBBAAAEE8iJAAM4LMxNBAAEEEECgvkBeAvCIESPk1VdfrT9l06Wv2Bs+fLgMGjRIbrzxxvDwsWPHytChQ+XII4+UOXPmhPvzAwEEEEAAgVIRyGkAXr9+vQwbNkyeeuop0ReMR6e7775bevXqJW+99ZZ8/vnnMm7cOFm3bp1ce+218swzz8hdd90lF154YXQ2uhFAAAEEECh6gUAu52DVqlVy5plnynbbbRdzMlOmTJFRo0bZl6OfeuqpMmHCBGnbtq3079/ffuvvNWvW2Jay+7LqO++8U2699dZweTruHXfcYV8WHe6Z4o9LXnlNdmpSKZcfNSTFnPkbXV8sri8+9/l8+ZtoilPSIxruS9pTzJq30fXl56FQyNMvkVeMWDuseUNKckLBYNCuj35/Tvfjk6xN7NF0WevfjtbVq0nXSa1fIJDTzXHGs5/pOrlx40Zp1apVxvUopQJyusQ18Orn7bffjmm2cOFCad++vR3Wrl07WbFihUT20wEahLV/t27d7HjaItZg7abvv/9eNDi3bt3a7ZXyd7/mzeQLEzwyKSPliaaYQYNbZWWlpwPwhg0bpKqqytMbEt0g68ZOLb2evLw+qp27s6U7hl5NGnyrq6ulRYsWXq2iaABWS7eR4dmKmoplsk42b97c09uvQrjnNAAnmqE2bdqIHqZu2rSp6Ma7c+fO4vZz827atEk6duzodtrhOo6bdEO6evVqtzOt76Ye3oCkNUNkQgABBBDwvEBBjx3p4ePp06dbpGnTpkm/fv2kT58+MmPGDLtXqIeftcVSDHuGnl/SVBABBBBAwFMCBQnAPXv2tIeVr7zySnniiSfsFc96EZYeWu7SpYucddZZcvzxx9uroPX8LgkBBBBAAIFSE8jLIeiRI0fWc4u8tWjMmDGih5mbNWsWHueiiy6S8847z55L9PIFHuEK8wMBBBBAAIEUBfISgBPVKTL4uuNy2NmV4BsBBBBAoBQFCnII2pOQ5lyzs3atJ6tGpRBAAAEESk+AAKzL1FyF7ZjbmTZccpEE58wuvaXMHCGAAAIIeE7AE4egC67SY1sJdOwk/hVLxDH3DJIQQAABBBDItQAt4FwLUz4CCCCAAAIxBAjAMVDohQACCCCAQK4FCMC5FqZ8BBBAAAEEYggQgGOg0AsBBBBAAIFcCxCAtwp/vWGT/KtdR9lobkciIYAAAgggkGsBArAR7teqpXSsaiI399hB3q2uzbU55SOAAAIIICAEYLMS7Nm6lfx1v71l582bxGGlQAABBBBAIA8CBOA8IDMJBBBAAAEEogUIwNEidCOAAAIIIJAHAQJwHpCZBAIIIIAAAtECBOBoEboRQAABBBDIgwABOA/ITAIBBBBAAIFoAQJwtAjdCCCAAAII5EGAAByFHPrma3EcbkaKYqETAQQQQCDLAgTgCFBfq1YS/OgDcVatiujLTwQQQAABBLIvQACOMPW1bSsSqDR9aAFHsPATAQQQQCAHAgTgHKBSJAIIIIAAAokECMCJhBiOAAIIIIBADgQIwDlApUgEEEAAAQQSCRCAI4QCPp/c0buvbAgGI/ryEwEEEEAAgewLEIAjTO/fq69826yFfF9XF9GXnwgggAACCGRfIJD9Iou3xO2aN5eAuQe49vXXpdq8HzicmlZJk5NPFZ+f/ZWwCT8QQAABBDISIKJE81VWir9DB/G1bBn+1P7nZZGNG6LHpBsBBBBAAIG0BWgBR9MFKqTyiGOkSbNm4SE1/34x/JsfCCCAAAIIZEOAFnA2FCkDAQQQQACBFAUIwCmCMToCCCCAAALZECAAZ0ORMhBAAAEEEEhRgACcIhijI4AAAgggkA0BAnA2FCkDAQQQQACBFAW4CjoZMHP/7+YH7hOpMFdIDz5CAvsOSCYX4yCAAAIIIBBXgBZwXJofBjT93dXm1qQhIubWpOAXX/wwgF8IIIAAAgikKUALOAm4QO8+dqzgt9+IVFcnkYNREEAAAQQQaFyAFnDjPgxFAAEEEEAgJwIE4BisCzZsjNGXXggggAACCGRPgAAcZbl/+3Zy/gczovrSiQACCCCAQHYFCMBRnnf07SN1TiiqL50IIIAAAghkV4AAnF1PSkMAAQQQQCApAQJwUkyMhAACCCCAQHYFCMDZ9aQ0BBBAAAEEkhIgACfFxEgIIIAAAghkV4AAnF1PSkMAAQQQQCApgaJ/EpbjOFJXVyc1NTVJzXCskSLz19bUijgSs7xgMCgSCsUcFqvcbPerrTV183BSR795bnbIGHk9ZbK+5GPeItfJfEwv3Wno34T9u0i3gBzn07oVi2Wpr5O6HHR7TfpBoOgDsM5Khb4kobLyh7lK8Vdk/oBZScQnMctzzHQcE2AymVaKVQuPrsE3EAiIz2cq59Hk1lHr6dWkOwf68XId1S5ynfSqpbvDpTtdXk1aNw3ChfibTdbEbUR4uY46L5muk5qfVF/Au1vK+vWM26UByf3EHSnBgMj8boBzv6OzaviLNyx63Gx3R9Yz22Vnqzyv19Fddu53tuY72+V43TFyfrGM1Ej/d6k7FtM6nf5STC2nd3ddU5uP/I0dNIdRqjeLoy1lEgIIIIAAAmkKFH0LOM35Tiubr2UrqXn531L75jiRJlXS4pFR4uOwSlqWZEIAAQTKXYAAnMIa0OToY6TySPNeYHM+dsPw88ScXNITIymUwKgIIIAAAghsESAAp7gmaIvXKYKrfFOcLUZHAAEEEMizAOeA8wzO5BBAAAEEEFABAjDrAQIIIIAAAgUQIAAXAJ1JIoAAAgggQABmHUAAAQQQQKAAAgTgAqAzSQQQQAABBAjArAMIIIAAAggUQIAAXAB0JokAAggggAABmHUAAQQQQACBAggQgAuAziQRQAABBBAgALMOIIAAAgggUAABAnAB0JkkAggggAACBGDWAQQQQAABBAogwMsY0kF3HJur7t2pMd+GVLHTzuLv2i2dksmDAAIIIFAmAgTgdBZ0ZaUEDjpY6t5/v0FuZ8VyCW6/gzQdflGDYfRAAAEEEEDAFSAAuxIR3yHTwP124ybx+US6N21qvs2PiKTdTS+MHWBrxo2V0NwvI8bmJwIIIIAAAg0FOAccZdIqEJAWgQoZPPkdGTh+sjzz7aKoMehEAAEEEEAgcwFawFGGbczh5U+HDLZ9f/XRx7I5GIwag04EEEAAAQQyF6AFnLkhJSCAAAIIIJCyAAE4ZTIyIIAAAgggkLkAAThzQ0pAAAEEEEAgZQECcMpkiTOEvvlaqsc8L866dYlHZgwEEEAAgbIUIABnebEH+vaTij37S93kiRKc+1WWS6c4BBBAAIFSESAAZ3lJ+rfZRqpOO0N8HTtluWSKQwABBBAoJQECcCktTeYFAQQQQKBoBAjARbOoqCgCCCCAQCkJEIBLaWkyLwgggAACRSNAAG5kUfWYPUeaf7ekkTEYhAACCCCAQHoCBOBG3Hq9M03azJ3XyBgMQgABBBBAID0BAnB6bolzmTcm1f73dXFqahKPyxgIIIAAAmUnwMsYoha58+FH4ry35T2/2332mXy7YoX8+6st9/O2+NEJMmTvvaJyxO6sOuMs2XTbSPMwjrXi69Ax9kj0RQABBBAoWwFawNGLvqpKpE0b++netq10bNdO/KZ7ien/3JKl0WPH7a7YeReRCvZv4gIxAAEEEChzASJE1Arg69Nb9KOpkzn/22n//cR/5BHy8uIlsvabb6PGphMBBBBAAIH0BGgBp+dGLgQQQAABBDISoAXcCJ/vxyeKdGjfyBgMQgABBBBAID0BAnAjbu6h6EZGYRACCCCAAAJpCXAIOi02MiGAAAIIIJCZAAE4M7/Gc1dUSPXjoxofh6EIIIAAAmUpQADO4WJvdtnlvBM4h74UjQACCBSzAAE4h0vP15EHcOSQl6IRQACBohYgABf14qPyCCCAAALFKkAALtYlR70RQAABBIpaIKe3IdWYFxFccsklMnv2bBk8eLDceOON9bDOPfdcO8ztefTRR8tNN90kt912m7z88su29zbbbCP/+te/3FH4RgABBBBAoCQEchqA7777bunVq5c8+OCDMmzYMBk3bpwMGTIkDPfYY49JKBQSx3Fk6NChogFY06uvviqvvPKKtGzZUnzmrUIkBBBAAAEESk0gp4egp0yZIj/96U+lsrJSTj31VJkwYUI9P+1fZV5y8MQTT8jAgQPlwAMPtAF51apVNgj/85//lGAwWC8PHQgggAACCJSCQE5bwAsXLpT27bc8yrGdeavQCvNqv+ikAfbee++V6dOn20FLly6VTp062c/MmTPluOOOk/Hjx4ez3XLLLXLDDTeEuwcMGGBb2GvXrg33S/XH5s2bE2bZtGmjLN+0SeaaeejUpEnC8e0I1TXiq66W9eecJc7Rx4pzvHm0ZZqprq5OKsx9xV4+IqCnHGpra8Xvz+l+XZqCW7Lp0RY96qKWXk7JrJOFrr/+7er66OXlrcta/3a8vCOv66TWLxDI6eY449Ul03Vy48aN0qpVq4zrUUoF5HSJtzGv8Vu/fr00bdpUNmzYIJ07d25g99prr8mgQYNEA7Smrl27yqRJk+zvY489VkaPHi2LFy+Wbt262X5XXXWVPa9sO8x/y5Ytsxv91q1bu73S+k6Uv6/4ZP2Cb+XpZSvkD717JjcNUyfn0b9IzWuvirN6tTTNoI4a3PSIgZcDsC5jPaLh5Q2JbpB1Y6eWXk+J1slC19/d2fLyzowG32qzE9yiRYtCc8WdvgZgtWyS7I593JJyPyCTdbJ58+ae3n7lXq/hFHLaVOnfv3+4ZTtt2jTp169fgxpoAD755JPD/efPn2/PF2sPDToawLt06RIerhv4tuY9ve4nX39YvVu3klN6dJOQE65KUj98VU3FV5lkizmpEhkJAQQQQKAUBHIagK+88kp7flcvsPr888/teWBF69mzZ/hwtF4hvccee4Qtd9xxR+nQoYOccsopst9++8nVV1/t+cOF4crzAwEEEEAAgSQFcnoIukePHjJmzBjZZM6dNmvWLFylOXPmhH9PnDgx/Nv9cc8994ieb9BDmV4+nOnWl28EEEAAAQRSFchpAHYrExl83X6JvvW8MQkBBBBAAIFSFcjpIehSRWO+EEAAAQQQyFSAAJypIPkRQAABBBBIQ4AAnAYaWRBAAAEEEMhUgACcqSD5EUAAAQQQSEOAAJwGGlkQQAABBBDIVIAAnKkg+RFAAAEEEEhDgACcBhpZEEAAAQQQyFSAAJypIPkRQAABBBBIQ4AAnAYaWRBAAAEEEMhUgACcomCtE5IN5g0r7idk3mSSTHJWLJe6GR+KY/KSEEAAAQQQIACnsA60N6+we2LBN7LzG2+GP5d/PDNhCX7zggnzUlLZ/NCDEpr7VcLxGQEBBBBAoPQF8vIs6FJhvGCnHeQXO24fnp1nv10k45YuC3fH+xHos4foZ+N1vxdJssUcryz6I4AAAgiUhgABOMXlWOHzhXNU/PAz3I8fCCCAAAIIJCPAIehklBgHAQQQQACBLAsQgLMMSnEIIIAAAggkI0AATkaJcRBAAAEEEMiyAAE4y6AUhwACCCCAQDICXISVjFIWx6md+o4Ev/wiZokVu+4mFT17xRxGTwQQQACB0hIgAOdxeVYeOUSCXy+Q0KqVDabqfPedBOfNlWYE4AY29EAAAQRKUYAAnMelWnnYYKmMM73aKZOk7sMP4gylNwIIIIBAqQlwDrjUlijzgwACCCBQFAIE4KJYTFQSAQQQQKDUBAjApbZEmR8EEEAAgaIQIAAXxWKikggggAACpSZAAC61Jcr8IIAAAggUhQBXQWewmPTFDFNXrpJjpkwNl7Jv+3Yysk969/KGFsyXzY89HC4r8kcoFBKnYyepOuWnkb35jQACCCBQpAIE4AwW3PFdt5EuVVXibC1j1tp18vyixWmVWLHnXlK5udq8rjAUM7+zdq3UjvsvATimDj0RQACB4hMgAGewzJpVVMigTh3DJVT6/WkHYH/rNtJkyFHhsqJ/VOuDOkwAJiGAAAIIlIYA54BLYzkyFwgggAACRSZAAC6yBUZ1EUAAAQRKQ4AAXBrL0c5F6K57xak255FJCCCAAAKeFyAAe34RJV9BZ+Ikkdra5DMwJgIIIIBAwQQIwAWjZ8IIIIAAAuUswFXQxbL0K8y+kjm8vPHG6+vV2D/tPfEtWWb7+ed/I3UDDxbRcU2q+PN9EjjoEPub/xBAAAEEvCVAAPbW8ohbG1/bdtL099c1PMR8hLl1qXrzlnzX3SwV114p0qyZ1E59R8TcusQCjkvKAAQQQKCgAmyfC8qf2sQrdttdfObpW/FS8L4/i//wweJr2VKCy5aKGTneqPRHAAEEECiwAOeAC7wAmDwCCCCAQHkKEIBLaLn7n3hMpEWLEpojZgUBBBAoXQEOQZfQsvV16lRCc8OsIIAAAqUtQAu4tJcvc4cAAggg4FEBWsBZXjBLN2+WW2Z/Lvqqwgt23F46mbclkRBAAAEEEIgWoAUcLZJBd5/WrWTY9tvZ4Dt64SKZsXpNBqVlmNW8manu3amy6b67xdm4McPCyI4AAgggkG0BWsBZFG1TWSlX776rLXHqylVZLDn1oirNqw392+8g1X97UpzV34uvefPUCyEHAggggEDOBGgB54y2sAX7O3SUygMOFF9lk8JWhKkjgAACCMQUKIkWsOM4op90U6b5407XVCmTekWXm25ZOZu/6Aqa7nxOK8bkE/ZyDd3vhBkKNILXHSNZsIzUSP236+d+p15CfnJkuk56ff7yo1h/KkUfgHWhBoNB8xKg9N8ClGn++qRbupyQI3XBuozqFV1uXV1ddK+E3WbXRDSfLwOfhBPZOoJOx2/OPRfDH1om60uyHpmMl4t1MpP6xMur9dSPV5NbP68vb/Xzeh0zXSc1fzFsG/K5Lhd9ANZHM1ZUVEilOf+abso0f6zp+vw+CVQEMqpXZLn6xxkIBBp9FGXk+O7vWjH1MPn8Gfi4ZSX6duuo0/NqCoVCoh8v11HtcrFOZnuZuDtcutPl1aR10w1/JtuHXM+bBiW19HId1SDTdVLzN/Yo3Vw7e7F8724pU9DShZrJgs00f9yqmkcxZ1Kv6HLTrWe6+aKnn0x3PqeVTH2ix3GXh/sdPdwr3V53jHTCMlIj/d+l7uj1+Ut/yaWf07u7runPEzkRQAABBBDwvEBJtIA9r1zICppWePXoZ8XXrLkE9tlHAvsOKGRtmDYCCCCAwFYBWsAlvipUnfMLqejdR5zaGql7/70Sn1tmDwEEECgeAVrAxbOs0qppYO99bL4aczFK6Ksv0yqDTAgggAAC2RegBZx9U0pEAAEEEEAgoQABOCERIyCAAAIIIJB9AQJw9k0pEQEEEEAAgYQCBOCEROmP8OX6DelnJicCCCCAQEkLEIBztHgP7NBeRpr3An+3aXOOpkCxCCCAAALFLEAAztHSG9FzN2keqBDz9NMcTSH1YoML5kv1s89IaE0B31OcerXJgQACCMjcuXNlzJgxJSVBAC6pxRl/ZgL99pLAgIFSN32ahObPiz8iQxBAAAEPCpx//vkyadKkpGpWU1PTYDx93rbXUtIB+L333pN+/fo1+hk7dqzX5o/6bBXwd+4sVSefIj7znmASAgggUEwCzz77rA2+Dz30kPzyl7+UqqoqmT9/vp0FjUs333yzPPfcc9K9e3c59NBDpW3btvKrX/3KDp89e7YMGTJEOnbsKBdeeKGsW7fOM7Oe9IM4dtttN3n44YcbrXjPnj0bHc5ABBBAAAEEUhU4+eST5cADD5TevXvLPffcI9rYGz16tJxwwgny6aefyosvvijaSFy8eLE8+OCDst1228m+++4r2mp+9NFHpUOHDrJo0SI56KCDbN6f/OQnqVYhJ+MnHYDbtGljK99YLTZv5oKjxnwYhgACCCCQukCTJk3s6xqbNm0qzZo1k5///Oc2AFdXV8sBBxwgu+yyiw3A+salY489VnS8bt26ydtvvy3jxo0TPSR9yCGHyIYNG+Sjjz4SrwTgpA9BR5K99dZbMmjQIOnbt6/sscce0qtXL+nSpYu8+uqrkaPxGwEEEEAAgawI6PuEtZGnwfScc86RGTNm2NbtsGHDwuXru5VfeuklmTlzpm0Na9Dt37+/Db7vv/++PQStrWavpLQC8EUXXSRHHXWUDcBnnnmmaPcOO+wgJ510klfmi3oggAACCJSQgB5SHjVqlNxyyy2y/fbby+GHHy4rV66U0047LTyXgUBA7rvvPhkwYIA9V7zXXnvJVVddJZMnT5bWrVvLP/7xD5s3nKHAP5I+BO3WU/cw1pjbWK699lr529/+Zk+EX3rppbJkyRJ54403ZOjQoe6ofCOAAAIIIJAVgdtvv12uueYaG0j1XO/atWvtOeB27dqFy9cAPHXqVNm4caM0b97c9tdgvHDhQju+BmEvpZRbwHqMvUWLFjYI77nnnvYYu85Q+/bt5ZtvvvHSvFGXOAJ1Mz4SJxSKM5TeCCCAgDcF9OpmDa7aAl6+fLnceOON4YpqwNXzvprc4BseaH54Lfhq3VJuAWsmvQxcL/2eN2+eLFiwwB4CGD9+vLz77rs6mORhgcrDBkv1E6OkyQknckuSh5cTVUMAgdgCLVu2lNra2gYDf/SjH4l+iimlFYD1mPoxxxwj2tzXC7L+/ve/y+WXXy4777xzMc17Wda18uBDpPrvfy3LeWemEUCgOAX0Xt5YQTfVudEYpUdwvZLSCsDnnXeeDcC77767PRRw3XXXeWV+qAcCCCCAQIkJ6OFmfRaFXgmdbtJTpHobUtEHYL0CWq9G0yeN6BVo5557ruy9997pupAPAQQQQACBRgX0SVZ61DXdpBcKey2lfBGWzoAGXX0Sid6HpU8cueCCC0QvyNJuUn2BWnOxU40HL3hyZn5Wv6J0IYAAAgjkVSCtAOzWUG+I1uPyIRNg9Eklfn9GxbnFlsx3m0ClHDBhimz32li5dc4XnpovZ8QfPFUfKoMAAgiUm0Ba7fmnnnpKHn/8cfniiy/krLPOsvcD61OxSPUFpg8eJLXmvulH5s2XRbwXuD4OXQgggECZC6QVgPVG5yuuuEKOP/54+3zOMjeMO/sBc0RAgQM+bxwZcN6ZKuZwhfi+WyrOd99J7f33m9r5xN9/b6k45KC488EABBBAoBQFRowYYd9xcNxxxxVk9tIKwI899lhBKstEMxNwxk8Ux5wyqAw0FVm9RpzX/yuhVd+LY1roBODMbMmNAALFI7B+/Xq5+OKL5c0335R99tmnYBVPOgBPnz5dhg8fbi+00vctfmdaUNHpftOi0vuDSd4U8F8/wlZML+SvO2yIVL7+qmx+9M8iO+3izQpTKwQQQCBCwDG3EWkjItXki3oE5apVq0TfY6AXERcyJR2A9T2MTz75pK3rAw88EPOm6J122qmQ88K0EUAAAQRKWGDzIw9JcPaslOewxd16uu2HpIFXP/q6wkKmpANwq1at7GudtLL6tglt6Z544olSVVVVyPoz7TQF/GefmWZOsiGAAAKFEWj226sKM+EcTTWtq4PcB3Fsu+22cskll8iHH36Yo+pRbK4E/Oedm6uiKRcBBBBAIAmBtAIwD+JIQrbIRgmecbbUHf9jCd00sl7NnRkfS/Csn0vwzHPEmfN5vWF0IIAAAgikL5D0IehYk+BBHLFUirOf8515TNuGjeKsXFV/BjZvFsdcsCDmfmYxD14hIYAAAqUiMHJk/QZHvucrrRawPojjkEMOkf33319WrFhhH8Tx3nvv2VcU5nsGmF4WBPRRmRpg9WN+O8FgxOeHYba/jktCAAEEEMhYIK0W8OTJk3kQR8b0hS+gbtgvpGL0GNOyrbaxV2vkfPChhB56RJ/PYZL5T4Py1hQc+6aY15GIr3cvqXjxWfHtsos7iG8EEEAAgRQF0moB6zuA+/Tpw1OwUsT22uiBvz0hgU2r7cdnnoTl26e/+C++UAKbt/QLbPpeKiaNE99RR4hvyGDxm9/VPztJAp+8T/D12sKkPgggUHQCabWAe/ToIZ9++ql9P2PRzTEVrifg85lWbpV5Mpa+SEMfmVkREJ92u8m8ZEP85tEdpiXs098kBBBAoAACs2bNEru9SnPa69atkw4dOqSZOzfZ0grAXbp0kVNOOUU6depkP27V7r77bjn66KPdTr6LSMDXsYM4ek93m9b1a22Crj5FxtFD0ebtTiQEEECgEAKVlZUZvXFPg7e+uc9LKa0AfN1118lVVzW8IXq33Xbz0rx5pi4VZsG/sWSZfL7u3YR1+tXOO8ox23RJOF62R6h44dmYRfr27i8Vzz1thznm+akkBBBAoBACu+66qwQCaYUsW109aquvzfVSSmtu9A0SS5YsaTAfd955pwwZMqRB/3Lvcea2PWTXli0SMvzjm4Xy8Zq1BQnACSvHCAgggAACWRVIKwDfdNNN5pbQLfeE6vfMmTNl9OjRsu+++2a1cqVSWNsmlTKkS+eEs/P2iqh7cBPmYAQEEEAAgWIVSCsA6/2/kemII46QhQsXil4dreeGSQgggAACCCDQuEBatyFFF6kX6Hz99deyZs2a6EF0I4AAAggggEAMgbRawHqed+nSpbY4Db4rV6609wQ/9NBDMSZBLwQQQAABBLwjsGzZMvnDH/4g3377rX2C44033liQC7TSCsC33XabVFdXhzWbNWsme+yxR0FmIFwJfiCAAAIIIJCEgN4ye+ihh8rpp58uelHx888/L2eddVYSObM7SsoBWFu8e+21l70cvLa21r7QWANwrMu79QItfV3h7NmzZfDgwaJ7GZFp+fLl9p3Cbj+9vem4446TsWPHyr333msv9HrwwQelZ8+e7ih8F1rALP/qZ56Win57SmCPvoWuDdNHAIEyEvjdJzPlw9Wpn+p8ceCAekqXXXZZ+BkWGr8WLVpUb3i+OlIKwLqXcOmll8rLL78s++yzjw2en332mX06iT6A47HHHqtXb93L6NWrl2gQHTZsmIwbN67ebUofffSRHHjggXLrrbfafHqjtT6t5Nprr7Xj6nnlCy+8UPTZ0yQPCLRoIU1OO0OCsz4TZ+0aArAHFglVQKCcBH6xw/Zysmn4pZpaBMzT/CJS165dbdfEiRPlhRdeKFiMSToA6znf888/Xx5//HEbfF988UX55JNPZM6cObY1rIeg9Y1I++23X3g2p0yZIqNGjbLnh0899VSZMGFCgwBcZZ6+dN9998nQoUPtYWwtr3///tK2bVv70Qu7tCXttrD10Pdm84o8N23cuNH9yXeOBfRJMk2GHi815mb20Fdf5nhqFI8AAgjUF+jdulX9Hhl0vfHGG3L99dfLa6+9Jm3atMmgpPSzJh2AP/jgA3vo2b3N6PXXXxcNqq1abQHRW5Hef//9egFYb01q3769rV27du3sqwsjq6rBUzfqffv2lQsuuEBuv/12WWXePevm0XE1EOsrD7t162az/vGPf5QbbrghXMyAAQNsC3vt2rXhfqn+iAzoqebN5vg15q1EFcEKiTUvdXV15kVE5k1ExqvgyewA+cxeaE2Uue4o6WkJvz5X2qNJT6Ho4+jU0svJK+tkY0ZB89pKXR+9vLx1WevfjtbVq0nXSa1fJk95yse8ZbpO6vbejRf5qG9j09CjsRpv9HSnxqZCpaQD8KZNm6Rly5bheuo9vw8//HC4e/Xq1dLaPDM4MulexXrz+MKmTZvKhg0bpHPn+g+j0Ad6uElXwGeeeUZOO+00m8ftr9Pt2LGj22n3WHSvxU167D7WtN3hyX5H1z3ZfNkcr0mTKqkyh0pi1UWDmx6i90IArjHLM2Tq0jRqeesy1iMaXt6Q6AZZ1zW19HqKtR54qc7uzpaXd2Y0+OpRsxbm9IlXkwZgtXSP8nm1nlqvTNbJ5s2be2L7pfOh54B1vdBrkzRp3Lnmmmvs73z+l3RTRc/5Tp061T71asyYMTboaatXk56rffPNN+2h48jK66Hk6dOn217Tpk2zl3tHDr/iiivsYWvt9/nnn9uWsL7mcMaMGfbh/3r4WTeYxbBiRs4XvxFAAAEEvCugb1aaO3eu6HVI+ilE8FWdpFvAO+ywg72KeeDAgVb1qaeesoHx2WeflYsvvlguuugi6d27dz3xK6+80u5p6P3BuvczcuRIO1yvan777bfl7LPPlt///ve21aSHXfW8sh4O0MvBjz/+eNF7te644456ZdKBAAIIIIBAKQgkHYB1ZrXZPnz4cHvOx22Vaot10qRJtvUaDaLvDdbWsh5G1ku93aQXWmnSQ8t6IlyvfI48N6DB/LzzzrOHMr18fsmdH74RQAABBBBIVSClAKyF6/ncyKQXUCVKkcE31riRwdcd7gZ4t7tcvt9ZsVJuN6/ejU7BUFAq7MVNP1yE1dKcL9bXF3rhvHB0felGAAEEsimg15hkcn2JFy/ESzkAZxOUsuoLnNhtGxNMRTabYBuddOWp0MD8Q/yVe+fMlTO36yHt8/2Oy49nis9cDyC//FV0NelGAAEEsi6gFwDrA50ySdpQ0YtEvZQIwB5aGvu0ayv6iZViXQX92LwFsUbNfT+zMyC1dbmfDlNAAAEEjMDee+9dkg5JXwVdknPPTKUvYFrpIfM0LIcHoaRvSE4EEChrAVrAZb34k59554MPJfjbq20Gv7n3OrRkidTttofpdqTipj9IxfALki+MMRFAAAEEkr8NCavyFvDts7cEJo6zCKG3xot/2nTxX/d7WT/8fGl+yknljcPcI4AAAmkIcAg6DTSyIIAAAgggkKkAAThTwTLM79NHknbuVIZzziwjgAAC2RPgHHD2LMumJN/+A0Q/JAQQQACB9AVoAadvR04EEEAAAQTSFiAAp01HRgQQQAABBNIXIACnb0dOBBBAAAEE0hYgAKdNR0YEEEAAAQTSFyAAp29Hzq0Cod/fgAUCCCCAQIoCBOAUwRg9hsBns2L0pBcCCCCAQGMC3IbUmE4RDJu+6ntpFfhhMbauDEi/Nm2KoOZUEQEEEChvgR+23OXtUJRzf1injnLXF1+F665vK5y1dp18PfQoaWLfHRwelPUfwaOPF6e6Wpp8+YU4K1ZJTfftpdJMJTTA3B/8r+ezPj0KRAABBEpNgABcxEv0mf33rVf76mBItn99rIQcDcW5TRX/fcVOILRmjYSOOUEqXnxWNv7jaQn07ZvbCVM6AgggUCICnAMukQVZqNnw6+Fu85Jrf9duIs2aFqoaTBcBBBAoOgECcNEtMiqMAAIIIFAKAgTgUliKBZ4H9zWFBa4Gk0cAAQSKSoAAXFSLi8oigAACCJSKAAG4VJYk84EAAgggUFQCBOCiWlxUFgEEEECgVAQIwKWyJJkPBBBAAIGiEiAAF9XiorIIIIAAAqUiQAAulSXpkfnwPf8vcVav9khtqAYCCCDgXQECsHeXTVHWzPfVPJHNm4uy7lQaAQQQyKcAATif2gWYVvCc8wowVSaJAAIIIJBIgGdBJxIq9uHfLhTHPBva5/PlbE5Cd94tzpS3pXLBApF586Vm4MEi5g1N+pjKwJtviK9du5xNm4IRQACBYhUgABfrkvNQvX2XXCy+X14gtcuXS9XFl4r/qisktGK51H0+WwJt23qoplQFAQQQ8I4AAdg7yyLjmlSYRm4z8xrCJ08+XfaYZ87FmtR7/nyZ1XcfadOkifRu3Uoqxv9XfFl+VaGvqXkJg/loub42baWid2+Rb76W4IJ5OW15ZwxGAQgggEABBQjABcTP9qQDJgDOOvoIqR1yeLjoqiFDZfOzT8sfzHuDxw86KNyfHwgggAAChRUgABfWP+tTb1ZRIfpxU9AE5RbmfGze0l8eFmnZ0raA8zZNJoQAAggUoQBXQRfhQkupyu3MOdgcXoDVoC7NmnHYuQEKPRBAAIGGAgTghiYl1adizHMlNT/MDAIIIFAqAgTgUlmSzAcCCCCAQFEJEICLanFRWQQQQACBUhEgAJfKkmQ+EEAAAQSKSoAAXFSLi8oigAACCJSKAAG4VJak1+ZjxUrxfTorXKvgPfdJ6LG/hLvj/Qg98FC8QeH+yYwTHjnqh/PddyIv/juqL50IIIBA/gUIwPk3L48pmlcS+uZ9HZ5X58WXxHn5lXB3vB+hMYmDYzLjxCtfzI6BTH477mAGIIAAAvkSIADnS5rpIIAAAgggECGQx0ckRUyVn6UpsGSJyP1/lqDfPJR6zhfi+/BjqW3Zfsu8mncEO4FKCXbfwb4pKbRff3EG7muH+V8ZKxIKbvn9yWdSPegw+1vM25RChx64pf+4iSKbNm35HTmOefBHaMhhtn/c/9auE//Era3e9RvFt2SpVH/6sR3d2XF7cfqaZ1ebVHnUMRLot6f9zX8IIIBArgUIwLkW9nD5Tm2tCXwh8VVVZaeW+uajs88Sf6BCQp/NEp85DC39twa0l8zh55YtxPezM2wArthtF5Hu3bZMd5vuph7Olt+33in+87e+w7hplfi323ZL/+7bidTWNRyn0rz2cMcdtvSP9391jcguu9uhzjffikycLP5hZ20Zu20bkc6dpG7q2xL88gsCcDxD+iOAQNYFij4A67tu3U+6OpnmT3e6qebTeqaTbD6TNTq/89ob4sydJ/7LL02n2IZ5zBuRnD372gCrb0by77uP+O+/244XNK1WadNaKq4b0TDf/gPD/YKP/00qzv5ZuDv8I5lxwiPH/xH8+BNxvlsqgahpBOfPVaAGRvFLyu2QYlknVSF6vcqtTOqle93S9XO/U5/D/OTI1DHT/PmZy/xOpegDsHIFg0Gp1dZcminT/GlONuVsdXVbW4Ap5gyafLryNzDS8oxdMAO7yKpo/fwm8NoNifntM61rt2yfE7IBrkEdIgswv3W8bIwTVewPndriN13R0wgFTf0qEk/7h4Jy+6tY1kmtp368mtz6RS9vL9bX63XMdJ308npSqPWh6AOwz7xoIGDe9tPEvO823ZRp/nSnm0q+mpoaqaysTOtFBwGTb5MJPJ9u2KiRR/wbzbdJrVZ9L03WrpWVi82tOSY52oLN4HD0JnOOttIcJg6YtzH5unaVbS+/TDptXS6hJx4Tnzk07UuwnJzHH83KOHaGYvwX7Lm7hH53eYP1xdE3SJlPJutRjMml3asY1kkNGLrDVRHx9q20ZzhHGXWnMGTWfa8s11iz6e4ce7mOWu9M10nNr9tr0g8CRR+Af5gVfsUT6GrOpTat8MtlMz6VnrPnyFnP/NOO6l+5SkLm4qjVEybb7tePOVqmHrTloqd4ZTXWP2Rar/oHpv/WmQ3fHm1ayT9kpy3T2n23xrKGh/l23SX8O96PZMaJm9fsZEgPc86ZhAACCBRYgABc4AWQj8nv2KKFTDz04C2TOvwQkYsvsL9Del+uOQe829ZzwIdnWJkNGzZIlWlB657uy4uXyNN6wRMJAQQQQCCmAPcBx2ShJwIIIIAAArkVoAWcW19Pl+7bpoukd121p2eLyiGAAAJFIUAALorFlJtK+gbsZ68Izk3plIoAAggg0JgAh6Ab02EYAggggAACORIgAOcIlmIRQAABBBBoTIAA3JgOwxBAAAEEEMiRAAE4R7AUiwACCCCAQGMCBODGdBiGAAIIIIBAjgQIwDmCpVgEEEAAAQQaEyAAN6bDMAQQQAABBHIkQADOESzFIoAAAggg0JgAAbgxHYYhgAACCCCQIwECcI5gKRYBBBBAAIHGBAjAjekwDAEEEEAAgRwJEIBzBEuxCCCAAAIINCZAAG5Mh2EIIIAAAgjkSIAAnCNYikUAAQQQQKAxAQJwYzoMQwABBBBAIEcCBOAcwVIsAggggAACjQkQgBvTYRgCCCCAAAI5EiAA5wiWYhFAAAEEEGhMgADcmA7DEEAAAQQQyJEAAThHsBSLAAIIIIBAYwIE4MZ0GIYAAggggECOBAI5KpdiESg6geCMj2Tz6tVx612xyy5SeejhcYczAAEEEEhFgACcihbjlqxA5aBDxde2bdz5Cy1eLLWTJhKA4woxAAEEUhUgAKcqxvglKeDv3kOamE+8VPfxDKlZtDDeYPojgAACKQtwDjhlMjIggAACCCCQuQABOHNDSkAAAQQQynJowwAAFeBJREFUQCBlAQJwymRkQAABBBBAIHMBAnDmhpSAAAIIIIBAygIE4JTJyIAAAggggEDmAgTgzA0pIYZAxfr1su1Xc2MMoRcCCCCAgAoQgFkPciLQ/NuFMvjl/+SkbApFAAEESkGAAFwKS5F5QAABBBAoOgEexFF0i8zDFV63TmTcWxKqqJD2Mz4Vv2kF/+fRx22F127bQ77fbVf72+/zyWnbdpcOTZp4eGaoGgIIIJBbAQJwbn3Lq/TqGpEvvxIxAXi7lculeXW1fP/ll9Zgjd8v83t0t7/fWrZcujdrKj/q1rW8fJhbBBBAIEKAAByBwc8MBTp2ELn8UvEHAtL205nSOuTIrn+6vUGhp737XoN+9EAAAQTKTYBzwOW2xJlfBBBAAAFPCBCAPbEYSrASXbcR30knluCMMUsIIIBAdgQ4BJ0dR0qJEvB17Ci+ww+L6ksnAggggIArQAvYleAbAQQQQACBPAoQgPOIzaQQQAABBBBwBQjArgTfCCCAAAII5FEgpwG4pqZGhg8fLoMGDZIbb7yxwWwtW7ZMLrroIjn++ONlxIgRouNruu222+SAAw6wn5NOOqlBPnoggAACCCBQ7AI5DcB333239OrVS9566y35/PPPZdy4cfW8dPihhx4qr7zyiu3//PPP2+9XX33V9ps4caI899xz9fLQgQACCCCAQCkI5PQq6ClTpsioUaOksrJSTj31VJkwYYIMGTIk7HbZZZdJp06dbHezZs1k0aJFEgqFZNWqVaJBWH+fdtpp4fH1x5o1a2T16tXhft9//70tP9yDHwgggAACCBSBQE4D8MKFC6V9+/aWoV27drJixYp6JF27bnkUobZ0X3jhBZk8ebIsXbrUBmUNzDNnzpTjjjtOxo8fH8732GOPyf/93/+Fu/v37y9//OMfZe3ateF+qf7YvHlzqlnyPn5dXZ15wmOF+MxzlL2a9BRCbW2t+M1jJxtLdcE62bRpU0bLrLHyGxvmOI7dsVPLlNLGjeILBvNW52JYJ4PGQ9fHRMs7Jecsj6w78fq3o3X1atJ1UusXME+Q83LKdJ3caP6GWrVq5eVZzHvdcrrE27RpI+vNe2GbNm0qGzZskM6dOzeYwTfeeEOuv/56ee2110TH18+kSZPseMcee6yMHj1aFi9eLN26dbP9rrzyStGPm7TVrC3i1q1bu73S+s40f1oTTSGTBjc9kuDlAKzLuKqqKuGGJFARED3iUQhz3SDrxk4tU0l1zZtLjQnazTNcz1KZZiF8Uqmfu7OV8s5MKhPJcFwNvtXmmeQtWrTIsKTcZdcArJZNiuDlJJmsk83N35CXt1+5W8LxS268qRI/X1JDtHU6ffp0O+60adOkX79+9fLpOeHbb79dxo4dK927b3lQ//z582XYsGF2PA06GsC7dOlSLx8dCCCAAAIIFLtATgOwtlSfeOIJGTp0qL0IS88Da+rZs6c9HK3ngL/99lsZPHiwaLDWYLzjjjtKhw4d5JRTTpH99ttPrr76anvotdihqT8CCCCAAAKRAjk9BN2jRw8ZM2aMPd+nhxzdNGfOHPtz1qxZbq963/fcc4/o+QY9J+L18yL1Kk4HAggggAACSQrktAXs1iEy+Lr9En3reWOCbyIlhiOQvoBjLnh0Zn4Wt4DQWz9c/Bh3JAaUjYB/+v/EKYILVotpgeQlABcTCHVFoFwEnM9mifOvl+LObuiW2+IOY0D5CQQee1zE3PZJyp4AATh7lpSEAAIIIIBA0gI5PQecdC0YEYEiEHDMA2KqX3whLzX1mVtnqs0tXVlPq9eIb+bWay++WSiy+DvTqllpJ+Nst63IipXiM/dravJ9NVdqrvjtlmF6j+rA/exv9z+9pUtvK6nz8L3pWkfH3HZWneJtZ+485utbb41zUr03PR+V+/xL8S3f8vwG36zZEvr3f8TXrq2dsu9HJ4gv4tqefFSn1KZBAC61Jcr85ETAv8OOEhh4gJgrCnNSfoNC9bnoJnhkPZl7tcUEYZvWm996Ts/tbt9OfOZJc7JhSwA2T7AID/NVBsSJnncNbib4evreTjU0wc3OS9Yxs1Ogo8WETB39KT4cJjuTb7yUtevC64C5WVlknXngkX/rw4DM/cukzAQIwJn5kbtMBPzmATFVp5+Zt7mtNk92q8rxQz9C4yeIvDNN/NePiDlfdYcNkcon/hJzmPYslgdxhMzRhCoexBF3OSY7YPOpZ4j/7LPEt/UJhsnmY7z4AgTg+DYMyZFAwOxBj5z9hTzw1byUpmDaWnLrHr1kP9NSIyGAAALFLkAALvYlWIT1v6NvH1ngHuZMof5/NOejvjKHUAnAKaA1Mqqv5+4ibbecz4s1mv+Ky2L1pl+ZCtSZ1m+VORJEyp4AATh7lpSUpEAPc+GGflJNjy/4OtUsjN+IgE+fr771GeuxRvOfeHys3vQrU4HQYYPEZ57nTMqeALchZc+SkhBAAAEEEEhagACcNBUjIoAAAgggkD0BAnD2LCkJAQQQQACBpAUIwElTMSICCCCAAALZEyAAZ8+SkhBAAAEEEEhagACcNBUjIoAAAgggkD0BAnD2LCkJAQQQQACBpAUIwElTMSICCCCAAALZEyAAZ8+SkhBAAAEEEEhagACcNBUjIoAAAgggkD0BAnD2LCkJAQQQQACBpAUIwElTMSICCCCAAALZEyAAZ8+SkhBAAAEEEEhagACcNBUjIoAAAgggkD0BAnD2LCkJAQQQQACBpAUIwElTMSICCCCAAALZEyAAZ8+SkhBAAAEEEEhagACcNBUjIhBfIHjiyeKsWxd/BIYggAACUQIE4CgQOhFAAAEEEMiHQCAfE2EaCGRLYNnmapm7fkPaxYVCIdFPIJDdVb9TXVBWmHo5vi37tH6fyA7Nm4vPZ36QEEAAgRgC2d0KxZgAvRDIlsBOLVrIqPlf20+6ZTo2oyM+8y/TdOkTT0q/WbNtMW0WfC0rjjxWQhUVtnvYH66X+w8aKMds0yXTyZAfAQRKVIAAXKILthRn6/peu4t+Mkna+g0Gg1JZWZlJMVvyHjU4XIaeA97vH38VX6tWtl//d9+TzWZaJAQQQCCeAOeA48nQHwEEEEAAgRwKEIBziEvRZSTQu5eYE8tlNMPMKgIIZCrAFiNTQfIjYAQqbv8/HBBAAIGUBGgBp8TFyAgggAACCGRHgACcHUdKQQABBBBAICUBAnBKXIyMAAIIIIBAdgQIwNlxpBQEEEAAAQRSEiAAp8TFyAgggAACCGRHgACcHUdKQQABBBBAICUBAnBKXIyMAAIIIIBAdgQIwNlxpBQEEEAAAQRSEiAAp8TFyAgggAACCGRHgACcHUdKQQABBBBAICUBAnBKXIyMAAIIIIBAdgSK/lnQjuOI+0mXJNP86U431XxaT68nr1u6hu53Tj23rpvpTMPrjpHzlBfLyAmm+Nvrlq6f+53i7OVt9EwdM82ftxnN44SKPgCrlb7ftba2Nm22TPOnPeEUM9bV1aWYI7+ja/38fr/dIcrvlFOfWibrSzJT041NXQbrZbGsk1pP/Xg1ufXL9fLOxvx7vY6ZrpNeXk+ysfzSKaPoA7DP5zNvgQtIkyZN0pl/myfT/GlPOIWMNTU19iXyOr9eTboB0Rfdq6dXUygUsgFD65nLlOl6WQzrpC5v3eGqqKjIJWVGZetOoS7zTLYPGVUgicy6s6aWXq6jzkam66Tm9/L2K4lFlfVROAecdVIKRAABBBBAILEAATixEWMggAACCCCQdQECcNZJKRABBBBAAIHEAgTgxEaMgQACCCCAQNYFCMBZJ6VABBBAAAEEEgsQgBMbMQYCCCCAAAJZFyAAZ52UAhFAAAEEEEgsQABObMQYCCCAAAIIZF2AAJx1UgpEAAEEEEAgsQABOLERYyCAAAIIIJB1AQJw1kkpEAEEEEAAgcQCBODERoyBQEkK8HaaklyszFQRCRCAi2hhUVUEsingTJgozsjbslkkZSGAQAoCBOAUsBgVAQQQQACBbAl4971x2ZpDykGgQALfbdosc9atS2vqGzZslBa5evWkeT2fpmbrN0j3YEh8W7t95tWCJAQQyJ8AATh/1kypjAR2bdVSHpm3wH7SmW3HMYHRl/2A2PPLr+SyUX+xVWpldg66BIPim/K27fb9/Gzxn31WOtUlDwIIpCFAAE4DjSwIJBIY2aeX6CfdtHbtWmndunW62ePnG3K4yMUX2OGh8RNE3pkm/utHxB+fIQggkDOB7O9i56yqFIwAAggggEDpCBCAS2dZMicIpCTga9dOZIftU8rDyAggkD0BDkFnz5KSECgqAV//vUQ/JAQQKIwALeDCuDNVBBBAAIEyFyAAl/kKwOwjgAACCBRGgABcGHemigACCCBQ5gIE4DJfAZh9BBBAAIHCCBCAC+POVBFAAAEEylyAAFzmKwCzjwACCCBQGAECcGHcmSoCCCCAQJkLEIDLfAVg9hFAAAEECiNAAC6MO1NFAAEEEChzAQJwma8AzD4CCCCAQGEECMCFcWeqCCCAAAJlLkAALvMVgNlHAAEEECiMAAG4MO5MFQEEEECgzAVK4m1IH374oSxcuDDtRVldXS1VVVVp589HxmAwKBUVFfmYVNrTqKmpkUAgIH6/d/frHMcR/Xi5jroAimGdDIVC4vP57CftlSbHGbWOdXV10qRJkxxPKbPii+HvO9N1ctmyZXL44YdnBlViuX1mY+QU+zzV1tamPQtTp06Va665RiZPnpx2GWTcInDRRRfJPvvsI+effz4kGQjo+tylSxdZvHixNG3aNIOSyPr444/L//73P3n00UfByFDgsMMOk5EjR8rBBx+cdkmVlZVp5y3FjCXRAs50oW7atEkyLaMUV45U50n3kHVPHstU5eqPr/vE69evt0cTsKxvk2qXtoB1vcQxVbmG4+t2UhOWDW3S7ePdY4XpzhH5EEAAAQQQKAIBAnARLCSqiAACCCBQegIlcQ44k8WycuVK+eyzz2TQoEGZFENeI/DRRx9Ju3btZIcddsAjAwE9BP3KK6/Icccd5/mLxTKYzbxkXbBggXz//ffSv3//vEyvlCei18n06dNHOnToUMqzmdd5K/sAnFdtJoYAAggggMBWAQ5BsyoggAACCCBQAAECcAHQmSQCCCCAAAJlHYDnzZsnP/nJT0Tvb3vxxRdZG1IQGDFihLz66qvhHPfee68MHjxYzjzzTFm3bp3tj2+YJ+aPZ599Vk466SQ57bTTwveh68NMhg8fbq9JuPHGG8P5YvmGB/JDbrjhBhk6dKj84he/kA0bNliRsWPH2n5HHnmkzJkzx/aL5wthfYFbb71V9B5qN8Va/2L5uuPznaSAPoijXNMxxxzjmKdoOStWrHDMRRqOuVijXCmSnm8TXJ2zzz7b6dq1q/PCCy/YfOZhJs4pp5zimAdIOA888IBjgrPtj298Vl3nBg4c6Jh7VO36Zx5g4ph7Vp3bbrvNueeeexwTKJzTTz/dMRs5J55v/NLLa8i4ceOciy++2M60+v3pT39y1q5d6+y77772b3rGjBnOIYccEh4e7VteWonnVte37t27O3fddZcdOdb6F883cemMESlQ1i3g7777zl4dqVf16dNd9Ik5pMYFVq1aZVu52tJw09tvv21bcvoYSm0BT5gwwQ7C1xVq+N2yZUt56aWX7CMS9WlXaqUPjZgyZYr89Kc/tQ87OPXUU61lPN+GpZZnH23hPvTQQ7JmzRoxwVZ69OhhW7x65XPbtm1lzz33tMO09RvLtzzVYs+1PgDm5ptvlt/97nfhEWKtf3pEIZZvOBM/khIo2wCstyZEPuZPb58xrZKk0Mp5pO22205My7YegT6Hu3379rafbvD01i586xE16NBnj3fu3Fk0KAwbNsw+DlWf9R1p6a6Tkf1c3wYF0kN+85vfyCeffCK9evWq56g06qZ/35GWri90PwhcccUVoqc+WrRoEe4Zaeauf5H9dETXN5yJH0kJlG0AbtWqlWzcuDGMpOeNdINISl2gTZs29tGJmlNNO3XqJPgmdtRH+5188sn26Msll1xiM0RauutkZD/XN3Hp5TfGk08+Kf/85z/l17/+tUSaqYRad+zYsV5/17f8pGLP8fjx40VfbPP+++/bIy/vvPOOPZIQaemuf5H9In1jl0zfeAJlG4D1cGmzZs1sa80ck5cPPvjA7jnHg6J/fAE9FDV9+nQ7wrRp06Rfv372Ocb4xjfTw80//vGP5YwzzpDLL788PGIsy1j9whn4YYPu/fffbyX0WeS6I60PjNDD0fq3rYem1VvfiIRl/BVGH6CjLWA9MtC8eXO7fYxnFs83fukMiSVQ1g/imDRpkpiLNmTz5s32asmrrroqlhH9Yghcd911dmOmV5HrRk9bcHpYasmSJfLyyy/LNttsI/jGgNvaa/To0XLuuefKbrvtFh5JWyDaKrvssstsi003gs8//7wNHrF8wxnL/Ie2yn72s5/Z8+ba0r3lllvsed+HH37YPlFMX4N3++23yxFHHGHX0WhffaUiqb7AqFGj7N0MGpDj/X3H8q1fCl2JBMo6ALs4GoAjzwe7/flOTUA3ftrqjU74Rosk7o5lGatf4pLKZwwNxLrTEpn0HHusd1RjGamU3O9YZvF8kyuRsQjArAMIIIAAAggUQKBszwEXwJpJIoAAAgggEBYgAIcp+IFAbgT0PHnr1q3tx+/321s83O7ly5fLTjvtJB9//HFuJk6pCCDgWQEOQXt20VCxUhTYdttt5emnn5ZDDz00PHuLFy+2t25VVlaG+/EDAQRKX4AWcOkvY+bQ4wL6IA59bvann34q55xzjpjHKtp3ruoDT7S/PqtcA7d5hGJ4TvQKc33Ckz4AQe8l5iEyYRp+IFA0AgTgollUVLRUBTTI6pXi+vn73/8uej+mPhBh6dKlYp4XLddff7385z//kZEjR4p5drToYesTTjhBrrzySpk9e7Z9uITeTkdCAIHiEggUV3WpLQKlLaC3cbn3o+t9q1988YW9f1XnWp/kpI9a1OCsD0I48cQTLca1115rA7J5eH5p4zB3CJSYAAG4xBYos1PcAt26dQvPgN7T2rNnz3C3PpVIH4qgDzzRw9W77757eJj+WLRokZi32NTrRwcCCHhXgADs3WVDzcpQQF/IkCgNGDBADjzwQNH3sbpJL+Qyr4h0O/lGAIEiEOAccBEsJKqIQKSAvn5Pn7390Ucf2d56VbVesKXPOyYhgEDxCNACLp5lRU0RsAJ6nvjWW28V85J5e8hZux955BFJpvUMIQIIeEeA+4C9syyoCQIpCej54NWrV9tbllLKyMgIIOAJAQKwJxYDlUAAAQQQKDcBzgGX2xJnfhFAAAEEPCFAAPbEYqASCCCAAALlJkAALrclzvwigAACCHhCgADsicVAJRBAAAEEyk2AAFxuS5z5RQABBBDwhAAB2BOLgUoggAACCJSbAAG43JY484sAAggg4AkBArAnFgOVQAABBBAoN4H/B3oTAhP9/A59AAAAAElFTkSuQmCC" }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Convert to a Plotly object." ], "metadata": {} }, { "cell_type": "code", "execution_count": 20, "source": [ "#%R ggplotly(plt)\n", "\n", "%R p <- plot.ly(\"https://plotly.com/~rmdk/173/lifespans-of-different-tumor-dna-profile/\")\n", "# pass object to python kernel\n", "%R -o p \n", "\n", "# Render HTML\n", "HTML(p[0])" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 20 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Using Python" ], "metadata": {} }, { "cell_type": "code", "execution_count": 21, "source": [ "f2 = tongue.type==2\n", "T2 = tongue[f2]['time']\n", "C2 = tongue[f2]['delta']\n", "\n", "ax = plt.subplot(111)\n", "\n", "kmf.fit(T, event_observed=C, label=['Type 1 DNA'])\n", "kmf.survival_function_.plot(ax=ax)\n", "kmf.fit(T2, event_observed=C2, label=['Type 2 DNA'])\n", "kmf.survival_function_.plot(ax=ax)\n", "\n", "plt.title('Lifespans of different tumor DNA profile')\n", "\n", "kmf2 = plt.gcf()" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAFRCAYAAACogdOJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xe8HGXd/vHPReg1dKQGBBR+GCI+IKhABEQUbI8oogIKYkRREZVmmYx0lEesSA+CgmBBQIq0UJQuoYOUBEhoIqEjAvn+/pg5YbM7p+/sbLner9d55czu7Mx3rzPJuXPf996jiMDMzMzMmme+qgswMzMz6zZuYJmZmZk1mRtYZmZmZk3mBpaZmZlZk7mBZWZmZtZkbmCZmZmZNZkbWNbTJG0u6Z6a7bdImibpOUl7V1lbmSQtIuk8Sc9I+t0Q9p8o6ZGa7TskbZF/L0mnSHpa0nX5Y3tJeiLPceny3om1M0kfk/RIfh1MqLtuJks6reoazcriBpb1BEkzJG1d/3hEXB0Rb615aD/gsohYMiJ+3roKW25HYAVgmYjYabgvjogNIuKqfPM9wDbAKhGxqaQFgKOBrfMcZzet6iHIf9ZbDfD8PI3FdiRpjqQXJD0v6SlJl0r6ZN0+UyW9LGnVmse2kTS94HhT8wbwgq2ov8aPgC/n18G0uuvGizBaV3MDy3pFMLR/0NcA7iq5lnawBvDPiJjTpGPNiIiX8+2VgIWBu0dyMEmj/XcpAI3yGC0haf4Bnh4fEUsA6wJTgJ9L+n7dPi8C3xvkHOOATYAngQ+PtNaC4w5UO5IErE7/f5864mdkNlJuYFlPq+3NkHQ5MJHsF9lzktaWtJCkH0l6SNLjko6VtHC+/3KSzpc0W9K/JV1Vc9wZkg6QdGfec3CypIXy58bmr3syf+48SavUvHaqpB9Iuiav42JJy+bPLSzp9LxXY7akGySt0M97Wy8/1ux8aOZD+eMp2S/lnfIeks8XvHYRSVPy+u4ENq57foakrSXtAZwAbJYf67e80bB6RtKl+f5vlXRJntM9kj5Rc6wpea4XSHoBmChpZUl/yDN6UNJXa/afLOksSafm+dwh6R35c6eR/VI/L6/nW3V1LwZcCKycP/+cpDflNRxcdF3UvN9vSbotf91JklaUdKGkZ/P3NrZm/w/nP/vZkq6Q9Na6Y+0n6Tbg+cEalBHxdEScDuwFHKg3hlwD+Cmws6S1BjjErsClwGnAbgOdK79eDpd0ff6+zuk7n6RxynrWdpf0EHCpMt/N39MT+c9kyfxafx4YA9wq6b6a917YuyhpU0l/zzObJmnLgWo1a3sR4S9/df0XMB3YquDxicAjNdtXALvXbP8YOAcYCywOnAsclj93OHAs2S+RMcC7a143A7gNWAVYGrgGODh/bhngY2S9PIsDZwF/qnntVOA+YO18nyuAw/PnJuU1LEzWA/B2YImC97UAcD9wADA/8F7gOWDd/PkE+PUAeR0BXJm/71WBO4CHi/Ik+6V9dc1zawBzgPny7cWAR/L95gMmAP8C1sufnwI8A2yWby8C3Ax8N699TeABYNv8+cnAy8B2eQaHAdcO9rOueX7L2p95/tgpwA8GuC6mA38HlgdWBp4A/gFsCCwEXAZ8P993XeAFYOv8uvh2/vOcv+ba+Ed+bSzUT41zgLUKfqavAu+vuVb3IBuOPS1/bBtget3r7gc+A6wD/BdYYYBspgIzgfWBRYHf1xx7XF7XlPxntDCwe/7exuU/5z/UXlf176Puuplcc+xVgKeA7Wrex1PAclX/2+Evf430yz1YZo0Ec4c49gT2jYhnIuIFskbVp/L9/gu8CRgXEa9HxN9qjhHAzyNiVmRzkA4Fdoa5PRJ/ioj/5Mc8jOyXfu1rT4mI+yPiP2QNsAk151wWWCcyt0TE8wXvYVNgsYg4IiJei4grgPP7asjf40BDNJ8ADs3f90zgJwPsX/94/fYOZL/0T42IORExDfhjfo4+50TEtfn348l+sR6S1z4dOJE3coesQXdRRARwOllDZ6iG+j7q/Swi/hURjwJXkzXqbo2IV4A/kTV2AXYCzo+IyyLidbJ5SIsA78qfD+Cn+bXxylCLjohXyRody9Q+THZNfkjS+g1vSHoPWePl3Ii4j2y47tMDnYasgXRXRLxE1tP5yfzvQp/JEfFyfm1+Bjg6ImZExIvAgcCnBuuVK/BZ4IKIuCh/r5cCNwEfHOZxzNqGG1hmjfrmai1P9r/4m/Nhi9lkw0vL5c//kKx34K+SHpC0f91xaidSP0zW84GkRSUdlw+XPEvWU7RU3S+xx2u+f5mspwuyYZ6LgTMlzZJ0pIrnwqxcd36Ah8h+2Q5F/esfHuLriqwBvLMvwzzHTwMr5s8HWa9J7f4r1+1/INmk/D5P1Hz/ErDwCH6pD1ftOV+u2/4Pb/yMVqYmr7wR+AjzZj/sSfbKPjywPPB07eMR8RTwc+AHNM4z3A34a00j/GwGGSak8ee+AG9c8/XPv4nsuqrdf37e+NkO1RrAJ+p+5u8mm89n1pEGnKRo1uOeIvtFun5EPFb/ZN779C3gW5L+H3C5pBvy3iLI5gJR8/2s/Ptvkg0jbRIRT0qaQDZkJAaZiB8Rr5H9Iv2BpDWAC4B7gZPrdn0UWE2S8l/wkP0Su4eheSyvuW8+1eoD7DuYh4ErI2LbAfapfd8Pk/V4rTuEfZv1/Itkjek+Q/nF3l+P1yzgbXN3yhrOq/HGz38oNRb5CPAacEPBcz8EHqx9TtIiwCeB+ST1Xb8LAWMljY+I2/o5T/1129dztlhB7Y+SDQ/W7v8a8zY+h+JhsuHCLw7zdWZtyz1Y1ksWVDZJvO9rTD/7CSCyT9idABwjaXkASatI2jb/fntlE+FFNr/pdbI5J33H+HK+/zLAd4C+9aYWJ2u4PZs/l/RXQ8OD0nslvS2v/XmyX36vF+x6HVnPzn6SFpA0kWyo7sx+3nO9s8gmVI9VtgzAVwd7wQDOB9aV9Nm8lgUkbVwz8bv+vd5ANvl7P2WT7cdI2kDS//Szf70ngDcP8vyykpaseWwa8EFJS0taCdhnaG+t0NnA9pK2ynudvknWw/X3YR6nb6h6GUmfIeulOiLmXfai71p9lmwu1v680QD6KFljZz2yIdQN8++vJpv43t85P6vsAxKLkjXmz65ppNc7A/hGPgF+cbLh7jNj+J9OPZ1smHPb/Oe9sLIPGgy1x9Ws7biBZb3kArJGR99XQvHyDbXb+5MNA16XD+ddQtb7BNmk4UvIGjp/B34REVfWHOO3wF/JJmjfBxySP3cM2Zycp/LXXThIDbU1rkj2C/xZsvk0U8mGDed9cTZf50PAB8gmlP8c2CUi/llwzCIp2dDPdOAi4NcD7D9ghnlP37Zkc6hmkfWOHQ4sWPT6/JfzDmTzzh7M6z8eWLJo//rz5cf+bj7UtG9DsRH3kDUMHlT2KcmVyDK8lWwC+kVkDdHh9ITNrSki7iWbU/SzvPbtgQ/lvY/Dcauk58mund2BfSJi8gA1/ISsQdVnV+DkiJgZEU/mX0+QXQuf7mdINciymEL2c1oQ+Fo/54Os5/Q04Cqyn9VLzNsYHyjD2sxmkvXQHUS2nMTDZA1T/46yjqX+/2OS7yCdTPYPxJMR8bZ+9vkp2T/kLwGfi4hbml2oWSdRttjjHhFxedW1mA2VpCvIhurqh5zNbJiG8r+DU8g+Dl1I0geBtSNiHeCLZB9bNzOzzuQFQM2aYNAGVkRcDQx0q4sPA6fm+15PNoFyuJ8gMTOz9jCSCfhmVqcZnyJchXk/tjuTbGHC4X6KxKxrRMSaVddgNlwR8d6qazDrFs2aQFjfpez/AZmZmVnPakYP1iyyNV76rMq8670AIMmNLjMzM+sYETHiOYnNaGCdC+xNtrL0psAz+UeBC8R8Ee7dqiVpcsFHr3uaMynmXIo5l2LOpZEzKeZcio22Y2jQBpakM8juk7acsrvLJ2S3TiAijouICyR9UNL9ZKshf36Aw60P3DmagrvQuKoLaEPjqi6gTY2ruoA2Na7qAtrUuKoLaEPjqi6gTY2ruoBuNGgDKyJ2HsI+ew/pbPO9ujUs4AaWmZmZdbXWrpK7zAPbt/R8nWFK1QW0oSlVF9CmplRdQJuaUnUBbWpK1QW0oSlVF9CmplRdQDcadCX3pp1ICtb66ws8+L6xEYX3TjMzMzNrC5JiNJPcW9uDtfydzwEbtfScbS6/Ca/VcCbFnEsx51LMuTQqKxNJ4a/O/irjumjGpwiHbvW/P8b1+2wN3NjS85qZmZVoND0dVZM0MSKmVl1HVcpqYLV2iPDra/6dnzz4YgTbtuSkZmZmJRvtUJJVq7+f32h/rq3twVrq4bHAeImFInilpec2MzMza5HWzsGa7/VVWeLR+4BNW3reNuZ5Eo2cSTHnUsy5FHMujZxJMedSjtY2sGAq7/jVI8DWLT6vmZmZWcu0uoF1EeN/swiwVYvP27Z6eWJhf5xJMedSzLkUcy6Nei0TSS9Iej7/miPppfz75yTNXUS8rFwkrSTpXEmz8vOvPsj+M/Ian5M0W9LfJE2SpJp9puTH2rjmsbUlzSk43hRJr0paqbnvbGha3cC6mKWnj0evbyixeIvPbWZm1jMiYvGIWCIilgAeAnbIt5eMiDNaUMIc4ALg40PcP8hqXBJYHTgC2B84qW6/p4FDBjqQpMXy894FfHYYNTdNSxtYkcSDKJ5jtb/dA2zeynO3K499N3ImxZxLMedSzLk0ciYgaUFJT0vaoOaxj0p6UdKykiZKminpQEn/kjRd0qdr9l1I0o8kPSTpcUnHSlq46FwR8WRE/Aq4abh1RsTzEXEesBOwm6T1+54CTgXGS9pigEN8HJgOHAXsNtzzN0Ore7AALuJ/jpuN52GZmZm1VET8FziDeXt1tgYujYh/59srAssCK5M1To6XtG7+3BHA2sCG+Z+rAN8vsd4bgZnM2ynzEnAYcOgAL90N+B1wLrC2pJYvcl5NA2udC5fDDSyg9+YEDIUzKeZcijmXYs6lUVWZSEQzvppY0q+BnWu2NwNOq9vnexHxakRcBfwF+GQ+F2pPYN+IeCYiXgAOBz7VxNqKPAosU7MdwHHA6pK2q985n+s1ETg7Ip4HLgZ2LbnGBlU0sK5k4dnrsNCza0ksW8H5zczMWiYCNeOrefXE9cDL+XDgW4E3k/X09JkdES/XbD8EvAlYDlgUuDmfhD4buDB/vEyrks27mivviTs4/6pvfO4C3BER/8y3zwY+Lamla3+2vIEVSbyIuI71f38f8N5Wn7/deE5AI2dSzLkUcy7FnEsjZzKPU8mGCXcBrskbLH2WlrRozfYaZL1ITwEvA+tHxNL519h8Unop8k8LrgxcU/tw/ucUYCyNk+h3BdaR9Jikx4BjyBqBHyyrziJV9GABXMyGp/4HL9dgZmZWhdOB/wU+A/y14PlU0gKSNge2JxtuC+AE4BhJywNIWkVSv7e/yyfA902CX7i/CfG1L8lft6SkHcjmi50WEXfWPg8QEa8BCdknDSN/3WbAWsDGZPPENgQ2AH5Li4cJq2pgTWOl2xYCtpGa1+3ZiTxPopEzKeZcijmXYs6lkTN5Q0Q8AvwDmBMRP6t7+nFgNlmv1WnApJrhtv2B+4HrJD0LXAKsS/9eAp4jawDdA7w4SGnnSXoOeBg4EDga+Hxt6cw7JHhGXmefXYFzIuLO/FOMT0bEE8BPgO0ljR3k/E3T0ps99900UanGEVxNGo8D/wL2iuChlhRiZmbWRJ16s2dJJwGzIuL7NY9NJOsxWq2ywlqsrJs9V9WD9QhieT6+81Zk46o3S3xNYkxF9VTGcwIaOZNizqWYcynmXBo5kzdIGkc2RHiScylHJQ2sSOJ1YAZvO3O1CA4D3g3sCPxNYoOBX21mZmYjJelg4HbgqIgoGj1qzdBWl6tkiBBAqc4Hjo8kzs2eZz6y9TUOAY4FDo3glZYUZ2ZmNkKdOkRomW4bIgR4gGwVWAAimBPBccAEYDwwTeLdVRVnZmZmNlJVNrDup6aB1SeCWcDHgO8CZ0vs1OrCWslj342cSTHnUsy5FHMujZxJMedSjrZrYAFEEBH8AZgE7NPSqszMzMxGqco5WOsAF0cSa/X/GuYnWwvjfRHc2d9+ZmZmVfEcrM7WjXOwZgCrKtUC/e0QwWvAKcAerSrKzMzMbLQqa2BFEq8CzwJLD7LrycAuEguVX1Xreey7kTMp5lyKOZdizqWRMynmXMpRZQ8WZHfHXmagHSJ4ALgN+EhLKjIzM+sCkl6Q9Hz+NUfSS/n3z0nauQXn317SNZJm5zdePkHS4gPsPyOv8bn8NX+TNEmSavaZkr+XjWseW1vSnILjTZH0qqSVmv/uBtf2DazcicAXSq6lEr43ViNnUsy5FHMuxZxLo17LJCIWj4glImIJ4CFgh3x7yYg4o2a/qSWVsCTwA+BNwHrAKsAPByo5r3FJYHXgCLJ7H55Ut9/TZGtm9kvSYsDHgbuAz46k+NHqlAbWn4CNJNYsuR4zM7OuJWlBSU9L2qDmsRUkvShpWUkTJc2UdKCkf0maLunTNfsuJOlHkh6S9LikYyUtXHSuiDgjIv4aEf+JiGeAE2Bo61tGxPMRcR6wE7CbpPX7ngJOBcZL2mKAQ3wcmA4cBew2lHM2W0c0sCL4D/Ab5r2jdlfw2HcjZ1LMuRRzLsWcSyNnAhHxX+AM5u3V+R5waUT8O99eEVgWWJmscXK8pHXz544gW2Jpw/zPVYDvMzRbAncMs94bgZnA5jUPvwQcBhw6wEt3A34HnAusLWmj4Zy3GeZv9QnrDLUHC7Iuwr9IpBG8XmJNZmZmTaNUTVkPKZKmLQXxa+As4IB8e1vgO3X7fC8iXgWukvQX4JOSDiW7pd34vEcKSYeTdYAcNNAJJb0P2BXYZAT1Psq8bYUAjgO+JWk7snU1a8+1OjAR2Csinpd0cX7uf4zg3CPWDg2swT5FCEAEt0k8SnYhXFhqVS3Ua3MChsKZFHMuxZxLMefSqKpMmtgwaoqIuF7Sy3mP3uPACmQ9PX1mR8TLNdsPkc2jWg5YFLi5dt45g4yGSdqUrBH28Yi4f6B9+7EqWXuh9j38N79p9cHAp+r23wW4IyL+mW+fDfxY0rci4rURnH9Eqh4inM3Qe7Agm+y+Z0m1mJmZ9YpTyYYJdwHOzocO+ywtadGa7TXIepGeAl4G1o+IpfOvsfmk9EKS3g78GfhcRFwx3CLzTwuuDFxT+3D+5xRgLNl8q1q7Auvkn1x8DDiGrHH4weGefzSqbmANZ4gQsvHU90qsWFI9Lec5AY2cSTHnUsy5FHMujZzJPE4H/hf4DHB7wfOppAUkbQ5sT9YIC7KJ6sdIWh5A0iqSti06QT6R/iJg74i4YIh1KX/tkpJ2IJsvdlpE3Fn7PEDeG5WQfdIw8tdtBqwFbEw2T2xDYAPgt2QNr5bpqAZWBM+RfaKwpSGZmZl1k4h4hGxO0hwaG1iPk40wPQqcBkyqGW7bn2zO03WSngUuAdal2L5kk+VPrlmPq6gxV+s8Sc+R3SbvQOBo5v2AW+Rffc7I6+yzK3BORNwZEU/mX08APwG2lzR2kPM3TWX3IgRQqk2Bn0QS7xz6cXgX2eru60XQmuLNzMz60an3IpR0EjArIr5f89hEsh6j1SorrMW68V6EMPwhQoBryVrcQ1pLw8zMzOYlaRzZEGH9Ip7WJB3XwMp7rbpmZXfPCWjkTIo5l2LOpZhzaeRMMvmn724HjoqIhwpy8ehQE1TdwHoGWEqphlvHacBHJZYqoSYzM7OuFRHfy2+Zc3jBc1MjYvUq6uo2lc7BAlCqZ4A1I4nZwzseZwOXRfCrZtVoZmY2XJ06B8sy3ToHC0Y2Dwu6aJjQzMzMuksnN7AuBZaXmNDkelrKcwIaOZNizqWYcynmXBo5k2LOpRxV3yoHRtjAiuB1iZOBb0jsEUHLlr83MzOrJTXnfoNVqbn1jTVJO8zBOhP4cyRxxvCPyYpkN6xcFTgSODWCV0ZdrJmZmfW0bpiD9S9gRAuaRfBEBFsCuwEfAx6Q2Edi0UFeamZmZlaadmhg/QH4nNKR909GcE0EHwA+AmwOTJc4qBOWcfDYdyNnUsy5FHMuxZxLI2dSzLmUY9AGlqTtJN0j6T5J+xc8v5ykiyRNk3SHpM8Ns4YryVZmnzjM1zWI4OYIPg5sBaxP1qN1sMRyoz22mZmZ2VANOAdL0hjgXmAbYBZwI7BzRNxds89kYKGIOFDScvn+K+Z3ua49Vr9jmUq1F7BNJPHxUb6fuvp5M9mNKXcETgGOjpjnppBmZmZmDcqeg7UJcH9EzIiIV4EzyYbhaj0GLJl/vyTw7/rG1RCcDrxXqZp6c8kIHojgi8B4YAwwzb1ZZmZmVrbBGlirAI/UbM/MH6t1AvD/JD0K3Ap8fbhFRBLPkzWyJg33tUM6fjAzgn2APwL7lXGOkfLYdyNnUsy5FHMuxZxLI2dSzLmUY7AG1lDWcDgImBYRKwMTgF9IWmIEtfwS+IJSLTSC1w7VIcAXJN5U4jnMzMysxw220Ogs5l1CYTWyXqxa7wIOBYiIByRNB94C3FR/MElTgBn55jNkDbOpAExmJXZiJuuxI/CbvhZ13/PN2oaYAnxH0u/LOL63R78dEVPbqZ522u7TLvW0w7avF18v3h7ddt9j7VJPxX9fJgLjaILBJrnPTzZpfWvgUeAGGie5/x/wbESkklYEbgbGR8TTdceKGGSymFJ9FNg/kthspG9oMBIrAHcD74iY29gzMzMzm2so7ZaBDDhEGNlk9b2Bi4G7gN9FxN2SJknqmy91GPA/km4luz/gfvWNq2E4H1hZqd4xwtcPKoInyYYjDyrrHMNR/z9Ncyb9cS7FnEsx59LImRRzLuUY9F6EEXEhcGHdY8fVfP8U8KFmFBNJvKZUxwLfAD7bjGP240TgBolJEUOaZ2ZmZmY2ZJXfi7Bhv1RLAveRrYt1e3n18ADwkQjuKOscZmZm1plKHSKsQiTxHHA42dBjmS4jW/HdzMzMrKnaroGVOxZ4m1K9p8RzXEY2eb9SHvtu5EyKOZdizqWYc2nkTIo5l3K0ZQMrkngF+D5w5GhuAj2IK4AtpcHnoZmZmZkNR9vNwZq7f6oxwDTgO5HEueXUxG3AnhFcX8bxzczMrDN13RysPpHE68CBwGF5Y6sMl+N5WGZmZtZkbdvAyv2FbMX3XUo6fuUT3T323ciZFHMuxZxLMefSyJkUcy7laOsGViQRwP5AqlQLl3CKK4FNJco4tpmZmfWotp2DNc9rU50LXBFJ/LjJZSFxHXBABFObfWwzMzPrTF07B6vOQcAB+SKkzdYWyzWYmZlZ9+iIBlYkcQfZTaf/p4TDVzrR3WPfjZxJMedSzLkUcy6NnEkx51KOjmhg5e4H1irhuH8HxkssUcKxzczMrAd1UgPrQeDNzT5oBC8DNwJbNPvYQzt/TK3ivO3MmRRzLsWcSzHn0siZFHMu5ei0BlYZPVjQBss1mJmZWfdwAytzORVNdPfYdyNnUsy5FHMuxZxLI2dSzLmUww2szI3AmhLLlXR8MzMz6yEdsQ4WQH7T5+eA1SKJZ5pXWX58cT5wagRnN/vYZmZm1ll6ZR2svlXdy56H5fWwzMzMbNQ6poGVK3seVssnunvsu5EzKeZcijmXYs6lkTMp5lzK4QbWG24HlpZYraTjm5mZWY/omDlYAEq1O/Bp4H35kGFTSUwB7ovg0GYf28zMzDpHz8zByp0GLAt8rqTjHwbsIzG2pOObmZlZD+ioBlYk8SpZ4+oopVq16ccP/gmcC3yr2cfuj8e+GzmTYs6lmHMp5lwaOZNizqUcHdXAAogkbgV+BpyQL93QbD8A9pJYoYRjm5mZWQ/oqDlYc4+VagHgeuDnkcTJzTjmPMcXPwNejWDfZh/bzMzM2t+o1+/sxAYWgFKNJ1u7aqNI4pFmHRdAYiXgTuAXwK8ieLSZxzczM7P21muT3OeKJG4DfkoJQ4URPA5sBiwD3CFxpsS7JJo+JOmx70bOpJhzKeZcijmXRs6kmHMpR8c2sHJHAMsDezT7wBH8M4K9gTWBa4FTgZskPiexcLPPZ2ZmZt2jY4cI5x431dvIVmF/RyTxcLOPP/c8Yj5gO+CrwEbAicCxEcws65xmZmZWjZ4dIuwTSdwOHAOcWNKnCrPzBHMiuCCCDwBbAEsAt0mcJbF5GcOHZmZm1pk6voGVO5JsvtQXWnGyCO6N4GvAOOBq4CTgFok9JZYYzrE89t3ImRRzLsWcSzHn0siZFHMu5eiKBlYk8RrZAqSHKdXqLTtv8FwEPwPeChwAfBB4ROIU92qZmZn1ro6fgzXPOVIdBEwE3l/GvQqHVINYEdiFbOL9GOBk4NQIHquiHjMzMxu+np+DVecoYGlgz6oKiOCJCH4ErA/sBqwN3CVxnsRHJRaoqjYzMzNrja5qYNUMFR6qVGtUWksQEVwbwReA1YA/At8kG0L8ocR64LHvIs6kmHMp5lyKOZdGzqSYcynH/FUX0GyRxJ1K9X9knyrctqqhwnlqCl4ATgFOkVgX2B24XGIGHHmNxMPAnBEc+rEIXmliqWZmZtYEXTUHa+65Us0P/B04KZI4rhXnHC6J+YEPkDW23j6CQ8wP/AvYJoJ/N7M2MzOzXtez9yIc9Hyp1geuBDaOJGa06rytkn9C8XCyxU+3ieCpiksyMzPrGp7k3o9I4i7gaEpegHS0Rjr2HUEABwIXkA03Lt/Muqrk+QDFnEsx51LMuTRyJsWcSzm6toGV+xHZiuuTqi6kDHkj6zvAn8kaWStUXJKZmZnRxUOEc8/b5UOFMHe4cDKwI7BVBE9UW5GZmVln8xDhIPKhwp8CB1ddS1nyJSES4CzgCoklq67JzMysl3V9Ayv3S+BDSrVs1YXUa+bYdwQpMA34WrOOWQXPByjmXIo5l2LOpZEzKeZcytETDaxI4t/A+WS3sOl2k4GvSyxVdSFmZma9quvnYM09f6rNgeOB9dth8dEySZwKPBDBD6quxczMrBN5DtbQXQMEsHnVhbTAwcDXJMZWXYiZmVkv6pkGVt5rdTzwxaprqVXG2HcE9wPnAt9o9rFbwfMBijmXYs6lmHNp5Eyq1YuJAAAfY0lEQVSKOZdyDNrAkrSdpHsk3Sdp/372mSjpFkl3SJra9Cqb59fADu042b0EhwBfye99aGZmZi004BwsSWOAe4FtgFnAjcDOEXF3zT5jgb8B74+ImZKWi4iG27ZUPQdrbh2pTgP+EUn8uOpayibxJWAvYNMIXq66HjMzs05R9hysTYD7I2JGRLwKnAl8pG6fTwN/iIiZAEWNqzZzHDCpnW+f00THAXeSrQNmZmZmLTJYA2sV4JGa7Zn5Y7XWAZaRdIWkmyS1+1IIfwNeB7aouhAod+w7v5XOJGBziV3LOk+zeT5AMedSzLkUcy6NnEkx51KO+Qd5fijLGSwAbARsDSwKXCvpuoi4r35HSVOAGfnmM8C0iJiaPzcRoBXbSnU8t3Ogsv6/lp+/drsmm/Ler/gEXHq1dJwizj61yvfr7VFtTwDaqR5vt/e2r5cK/r3txG1ggqS2qafi62MiMI4mGGwO1qbA5IjYLt8+EJgTEUfW7LM/sEhETM63TwQuiojf1x0rog3mYAEo1QTg1Ehiw6praRWJzwH7Ae/wfCwzM7OBjbbdMtgQ4U3AOpLGSVoQ2Ins4/+1/gy8R9IYSYsC7wTuGmlBLTIdeHOPzMMCIIIpwP202TIVZmZm3WjABlZEvAbsDVxM1mj6XUTcLWmSpEn5PvcAFwG3AdcDJ0REWzewIolngf8Ay1ddS33XdckSYH+JRVp4zmFrcSYdw7kUcy7FnEsjZ1LMuZRjsDlYRMSFwIV1jx1Xt/0j4EfNLa10DwJrAU9WXUirRHCLxHXAl4CuX6bCzMysKj1zL8J6SnUGcF4k8duqa2klifFkPZJrR/Bi1fWYmZm1o7LnYHWzB4E3V11Eq0VwG9lSFXtVXYuZmVm36vUG1lpVF1HR2PfBwDck2qZHsZbnAxRzLsWcSzHn0siZFHMu5XADqwdFcCvwKvDWqmsxMzPrRr08B2sN4JpIYrWqa6mCxCnAjRH8supazMzM2o3nYI3cTGB5pVq46kIqMpVsxVozMzNrsp5tYEUSrwN3AJtXWUeFY99XABPbcR6W5wMUcy7FnEsx59LImRRzLuXo2QZW7mR6dGXzCB4GngeOknhf1fWYmZl1k56dgwWgVEuR3Xz6rZHEExWX03ISHwE2IWtkbpNPfjczM+t5noM1Cvktc/4AfL7qWqoQwZ8j+A7wDeBMicWqrsnMzKwb9HQDK3c8sKdSVZJFO4x9R3A6cAPwk6prgfbIpB05l2LOpZhzaeRMijmXcriBBTcCzwFbV11Ixb4CbCGxU9WFmJmZdbqenoPVR6n2AraOJHasupYqSWwEXAS8M4LpVddjZmZWldG2W9zAApRqSeAhYL1I4vGq66mSxD7AvmQr3Y/GaRGc1ISSzMzMWs4NrCZRqhOAByOJw1t6XmliRExt5TkHkq+L9U5gNAuwrgD8GFg9gteHX0N7ZdIunEsx51LMuTRyJsWcS7HRtlvmb2YxHe544HdKdWQkMafqYqoSQQDXjfY4EgcAWwKXj7ooMzOzDuMerJxSCbgJ+CswOZJ4peKSOprEN4H1I9ij6lrMzMyGy+tgNUkkEcBHgLcCtyn1x1ZH6UzgY9KohhrNzMw6khtYNSKJmZHEx4D9gF8r1RSlWq7Mc3br+iMRzAJuAbYf7mu7NZPRci7FnEsx59LImRRzLuVwA6tAJPFn4P8BTwN3KtXn8yFEG57fAJ+puggzM7NW8xysQSjVRsBxwIvAlyKJeyouqWNILAU8DIyLYHbV9ZiZmQ2V52CVLJL4B7Ap2T0Lr1aqHyiV5xUNQQTPApcAPb2Aq5mZ9R43sIYgkng9kvgZMAFYn2wSfFNurdMDY9/DHibsgUxGxLkUcy7FnEsjZ1LMuZTDDaxhiCRm5bfT2Rc4SalOU6oVqq6rzV0AvE1itaoLMTMzaxXPwRohpVoMmAzsChwEnNLLC5QOROIE4L4Ijqq6FjMzs6HwrXIqplQbkk2CfxWYFEncVXFJbUdiIvCTCDasuhYzM7Oh8CT3ikUStwLvBs4ArlSqQ5Vq8aG+vkfGvq8ClpHYYCg790gmw+ZcijmXYs6lkTMp5lzK4QZWE+ST4H8JjAdWB+5Tqr2VasGKS2sLEcwha4B6TSwzM+sJHiIsQT5seDjZbXe+B5zR6/OzJDYE/gyslTe4zMzM2pbnYLUxpdoSOAJYBDgQuCi/52HPkRAwDdgvgourrsfMzGwgnoPVxiKJK4F3kX3a8GjgCqXatHafXhn7jiDIevUm542tfvVKJsPlXIo5l2LOpZEzKeZcyuEGVskiiYgkziGbn/Vr4Cyl+pNSrVdxaVU4G1gK2LbqQszMzMrkIcIWU6pFgK8A+wHnA0kk8Ui1VbWOxE7AN4DN8l4tMzOztuM5WB1KqcaSNbImAacAh0cS/662qvJJjAFuA74ZwUVV12NmZlbEc7A6VCTxTCRxECexJ7AYcK9SHZSvEN+1IngdSIG0v7lYng9QzLkUcy7FnEsjZ1LMuZTDDayqPcLTkcRewGbAhmRraO2lVAtUXFmZfk/WqPxA1YWYmZmVwUOEbUap3kH2abs1ge8CZ3fjGloSnwC+DbzTc7HMzKzdeA5Wl1KqrYEjgenATt3WyJKYD7gVmA1cEUFScUlmZmZzeQ5Wh+tv7DuSuIzsHoerAAe1sqZWyFdz3xY4FJgksX7fc54PUMy5FHMuxZxLI2dSzLmUww2sNhZJvALsCHxJqXaoup5mi+CxfFX3n5F9otLMzKwreIiwAyjVZmT38ds8kri36nqaTWJp4AFgQgQPV12PmZmZhwh7QCRxLfAd4BylWrLqepotgtnAScC+VddiZmbWDG5gVWyoY9+RxAnAlcCvlaobf27HALtJLOf5AMWcSzHnUsy5NHImxZxLObrxF3U3+xqwHNnyDV0lglnAH4C9q67FzMxstDwHq8Mo1UrAjcBXIolzq66nmSTeAlwDrBnBC1XXY2ZmvctzsHpMJPE42ScLT1Sqt1ZdTzNFcC/ZMOgXqq7FzMxsNNzAqthIxr4jieuBA8gmvS/V9KKqdQRcdojEDRLvqbqYduJ5EsWcSzHn0siZFHMu5Zh/sB0kbUc2AXkMcGJEHNnPfhsD1wKfjIg/NrVKaxBJnJzfVud8pbqmn91mRhK/aGVdoxXBTdJPvwRbrwRMBrapuCQzM7NhG3AOlqQxwL1kv+Rmkc392Tki7i7Y7xLgJeCUiPhDwbE8B6vJlGpBYBKweD+7HASsHknMbl1VzSGxIPAQ8L4I7qi6HjMz6y2jbbcM1oO1CXB/RMzIT3Ym8BHg7rr9vgr8Hth4pIXY8EUS/yVbBb2QUm0FvAc4r2VFNUkE/5X4Fdm1NanqeszMzIZjsDlYqwCP1GzPzB+bS9IqZI2uY/OHWvOxxC5R8tj3VcAWJR6/FDWZ/Ar4pMQyFZbTNjxPophzKeZcGjmTYs6lHIP1YA2lsXQMcEBEhCQB/XanSZoCzMg3nwGmRcTU/LmJAL22XZNN84+/Mc+yPTu00/sdfj5xLrCnpOvboZ6KtycA7VSPt9t729dLK/+97eBtYIKktqmn4utjIjCOJhhsDtamwOSI2C7fPhCYEzUT3SU9CHMbVcuRzcPaM2LeNZrkOVgtp1QLA08BK0USHbmulMQ7gD8Ba0XwWtX1mJlZbxhtu2WwIcKbgHUkjZO0ILATME/DKSLWiog1I2JNsnlYe9U3rqwakcR/gH8Am1Vdy0hFcDPwMPDRqmsxMzMbqgEbWBHxGtmtSy4G7gJ+FxF3S5okyROPm6C+67oEVwFblnyOpirI5CfA1ysopa204FrpSM6lmHNp5EyKOZdyDLoOVkRcCFxY99hx/ez7+SbVZc1zFZ1/78I/AUdLbEu2bEiPWnmhqiswM7Oh8b0Iu5xSLQE8BiyXDxl2JIndgaTqOio0BngUeGeEP6lrZla20bZb3MDqAUp1PfDtSOKqqmuxkZGYD7gD+FoEl1Zdj5lZtxttu2XQIUIrl6SJNR+VLctVwNZKdfMQ9n0pkha1uvvRokw6SgRzpCPOhQO+DW5g1fL1Usy5NHImxZxLOXyz595wIfBN4MlBvp4CrlWq9Suq0wb0o8uADSQmVF2JmZkNzEOENpdSzQd8ETgEOBr4YSThtafaiMR+wPgIPlt1LWZm3cxzsKzplGoN4ERgLPD5SMI3W24TEksBDwIbRfBQ1fWYmXWrshcatZK14/ojkcRDwLbAccAVSvU9pVqgVedvx0zaQTZPgmeBk4F9qq6nXfh6KeZcGjmTYs6lHG5gWaFIIiKJE4GNgHcB1yvVhhWXZZmfALtJLF11IWZmVsxDhDYopRKwG3AU8EvgsEjiv9VW1dskpgD/jOCwqmsxM+tGnoNlLaNUqwC/AlYHdo8khrLsg5VAYgPgEmDNCDp2AVkzs3blOVgdrpPGviOJWcCHgR8CFyrVoUrV9Nu3dFImrVSbSwR3ALeAP03o66WYc2nkTIo5l3K4gWXDks/NOh3YEFgf+IdSbVJxWb3qKOBb+SrvZmbWRjxEaCOWz83aiWzS9RQg6eT7HXYaCQE3AIdE8Oeq6zEz6yaeg2WVU6oVgZ8DbyNbN+vaikvqGRKfAPaJ4N1V12Jm1k08B6vDdcPYdyTxRCTxCeC7wB+V6milWnSkx+uGTMrQTy5/BFaSeFeLy2kbvl6KOZdGzqSYcymHG1jWNJHE78l6sVYGpinV5hWX1PUieJ3stkbfrroWMzN7g4cIrRRK9VGyNbPOBg6KJF6suKSuJbEoMB3YIoJ7q67HzKwbeIjQ2lIkcQ6wAbAMcJtSd0GXJYKXyBqz36y6FjMzy7iBVbFuHvuOJJ6OJHYBvg6crlS/UKrFB3tdN2cyGoPk8gtgR4mVWlRO2/D1Usy5NHImxZxLOdzAstJFEueTzc1aFLhdqbauuKSuE8FTwG+Br1Zdi5mZeQ6WtZhSfQA4DrgQ+HYk8VzFJXUNibXI1sVaM4Lnq67HzKyTeQ6WdZRI4kKy3qz5yHqz3l9xSV0jggeBy4C9q67FzKzXuYFVsV4c+44kno0k9gS+ABynVCcp1di+53sxk6EYYi4HAvtKrFNyOW3D10sx59LImRRzLuVwA8sqE0lcQtab9V+y3qztKy6p4+W9WAcDJ/kehWZm1fEcLGsLSrUVcCJwNbBPJDG74pI6Vt6wuhr4bQS/qLoeM7NO5DlY1hUiicuB8cBzwB1K9eGKS+pYEcwB9gBSiXEVl2Nm1pPcwKqYx77fEEm8EEl8lb9wJPB/SvUbpVq26rraxXCulQjuAX4InCDR1T3H/jtUzLk0cibFnEs53MCy9nMjt5H1Zj1JNjfrfyuuqFMdDSwNfL7qQszMeo3nYFlbU6p3AycD04CvRBJPVVxSR5EYD1wKvD2CWVXXY2bWKTwHy7paJPE3YALwL+B8pVqg4pI6SgS3kd2n8FfdPlRoZtZO3MCqmMe+G9VnEkm8DHwNmA0kVdTUDkZxrRwGjAN2bloxbcR/h4o5l0bOpJhzKYcbWNYRIok5wOeA3ZVqy4rL6SgR/JdsHtaPJVaouh4zs17gOVjWUZRqO+B4YEIk8XTV9XQSiSOBcRHsVHUtZmbtbrTtFjewrOMo1Y+B1YEdI2nRBdwFJBYh+7DAgRH8sep6zMzamSe5dziPfTcaQiYHAG8mu5dhzxjttRLBy8DuwM8llmlKUW3Af4eKOZdGzqSYcymHG1jWcSKJV8gmbB+mVOtVXU8nieBvwNnAj6uuxcysm3mI0DqWUn0R+DLwzrzRZUMgsRhwO/CVCC6suh4zs3bkIULrZScADwCHV11IJ4ngRWBP4DiJJauux8ysG7mBVTGPfTcaaib5BPc9gR3zTxd2tWZeKxFcBlwEHNWsY1bFf4eKOZdGzqSYcymHG1jW0fKlGnYFTlaqFauup8N8G9heYquqCzEz6zaeg2VdQakOBTYCts8XJbUhkNge+CkwPh86NDMzPAfLrM9kYGngqxXX0VEi+Avwd+CQqmsxM+sm7sGqmKSJETG16jrayUgzUaq1gOuB90US05peWMXKulYkliX7VOEfgQ78NOYpq8LnZ1ZdRftxLo2cSTHnUkz7jqbdMn8zSzGrUiTxoFJ9AzhDqd4RSbxUdU2dIIJ/S3wImFh1LSPzwiLAo1VX0X6cSyNnUsy5lME9WNZ1lOp0YGFgj0ji2arrMTOzzuM5WGaNJgH/Au5Qqh2qLsbMzHrPkBpYkraTdI+k+yTtX/D8ZyTdKuk2SX+TNL75pXYnrz/SaNT33EvixUhiL7LlG45Rqt8o1XJNKa5CvlaKOZdizqWRMynmXMoxaANL0hjg58B2wPrAzlLD/d8eBLaIiPHAwcDxzS7UbLgiiSuADYEngNuV6pNK5WFqMzMr3aBzsCRtBiQRsV2+fQBARBzRz/5LA7dHxKp1j3sOllVGqTYFTgbuBb4cSTxWcUlmZtbGWjEHaxXgkZrtmflj/dkDuGCkBZmVIZK4Dng7cCdwq1J9zr1ZZmZWlqE0sIb8MUNJ7wV2BxrmaVkxj303KiuTSOKVSOK7wPuBrwMXKtXqZZyrDL5WijmXYs6lkTMp5lzKMZR1sGYBq9Vsr0bWizWPfGL7CcB2ETG76ECSpgAz8s1ngGl9Cyf2/YB7bbsmm7aopxe2I4lbtLC+xTZ8io25Wam+zw+4hzlEO9Q3wPYEoJ3q8XZ7b/t68b+3Q9oGJkhqm3oqvj4mAuNogqHMwZqfbN7K1mQLkd0A7BwRd9fsszpwOfDZiLiun+NEeA6WtRmlWg84CXgV+EIkcV/FJZmZWRsYbbtlSAuNSvoAcAwwBjgpIg6XNAkgIo6TdCLwMeDh/CWvRsQmzSzUrCxKNYbsHobfBY4AfhxJvF5tVWZmVqWWNLCawQ2sYpLvRVivqkyU6s1kw9yLAbtHEne2uoaB+Fop5lyKOZdGzqSYcyk22naLV3I3y0USD5ANhZ8ETFWq7yvVghWXZWZmHcg9WGYFlGo14FfAqmS9WTdXXJKZmbWQhwjNSpKvk/UZ4GiyRUrTSOI/1VZlZmat4CHCDlf/8WFrn0wiiYgkTgfGA2sD05Tq3VXV0y65tBvnUsy5NHImxZxLOYayDpZZT4skngA+oVT/C5ytVGcDp8PQF+Ftigm8RaleaOk5B/ZUJDGj6iLMzNqRhwjNhkGplgGOJLvtTq97C7BGJPF01YWYmTWb52CZWSWU6lzgzEjit1XXYmbWbJ6D1eE89t3ImRRrw1zOAz5UdRFtmEtbcC6NnEkx51ION7DMbKT+ArxfqRaouhAzs3bjIUIzGzGlugn4diRxRdW1mJk1k4cIzaxKbTFMaGbWbtzAqpjHvhs5k2Jtmst5wA5VFtCmuVTOuTRyJsWcSzncwDKz0bgFWFSp3lJ1IWZm7cRzsMxsVJTqV8D9kcSPqq7FzKxZPAfLzKp2Pp6HZWY2DzewKuax70bOpFgb53IZ8PZ8lfuWa+NcKuVcGjmTYs6lHG5gmdmoRBIvA1OB7SouxcysbXgOlpmNmlLtCWwVSexcdS1mZs3gOVhm1g68qruZWQ03sCrmse9GzqRYO+cSSTwKPAi8p9XnbudcquRcGjmTYs6lHG5gmVmzVL7oqJlZu/AcLDNrCqXaCDgzkli36lrMzEbLc7DMrF3cAizmVd3NzNzAqpzHvhs5k2LtnkskEVSw6Gi751IV59LImRRzLuVwA8vMmuk8vKq7mZnnYJlZ8yjVIsATwLhI4umq6zEzGynPwTKztuFV3c3MMm5gVcxj342cSbEOyqWlw4QdlEtLOZdGzqSYcynH/FUXYGZd53zgh0r1QkvOtitjlOr1lpxr9C6IJD5ZdRFmVj7PwTKzplOqhfF/4Iq8ng+jmlmbG227xQ0sMzMzszqe5N7hPPbdyJkUcy7FnEsx59LImRRzLuVwA8vMzMysyTxEaGZmZlbHQ4RmZmZmbcYNrIp57LuRMynmXIo5l2LOpZEzKeZcyuEGlpmZmVmTeQ6WmZmZWR3PwTIzMzNrM25gVcxj342cSTHnUsy5FHMujZxJMedSDjewzMzMzJrMc7DMzMzM6ngOlpmZmVmbcQOrYh77buRMijmXYs6lmHNp5EyKOZdyuIFlZmZm1mSeg2VmZmZWx3OwzMzMzNrMoA0sSdtJukfSfZL272efn+bP3yrp7c0vs3t57LuRMynmXIo5l2LOpZEzKeZcyjFgA0vSGODnwHbA+sDOktar2+eDwNoRsQ7wReDYkmrtVhOqLqANOZNizqWYcynmXBo5k2LOpQSD9WBtAtwfETMi4lXgTOAjdft8GDgVICKuB8ZKWrHplXavsVUX0IacSTHnUsy5FHMujZxJMedSgsEaWKsAj9Rsz8wfG2yfVUdfmpmZmVlnGqyBNdSPGNbPsm/NRxO7w7iqC2hD46ouoE2Nq7qANjWu6gLa1LiqC2hD46ouoE2Nq7qAbjT/IM/PAlar2V6NrIdqoH1WzR9rIMkNrwKSdqu6hnbjTIo5l2LOpZhzaeRMijmX5husgXUTsI6kccCjwE7AznX7nAvsDZwpaVPgmYh4ov5AXgPLzMzMesWADayIeE3S3sDFwBjgpIi4W9Kk/PnjIuICSR+UdD/wIvD50qs2MzMza2MtW8ndzMzMrFeUvpL7UBYq7RWSZki6TdItkm7IH1tG0iWS/inpr5K6/uOykk6W9ISk22se6zcHSQfm1889kratpury9ZPLZEkz82vmFkkfqHmu63ORtJqkKyTdKekOSV/LH+/p62WAXHr9ellY0vWSpkm6S9Lh+eM9e70MkElPXyt9JI3J3/95+XbzrpWIKO2LbFjxfrJPKCwATAPWK/Oc7fwFTAeWqXvsKGC//Pv9gSOqrrMFOWwOvB24fbAcyBa4nZZfP+Py62m+qt9DC3NJgH0L9u2JXICVgAn594sD9wLr9fr1MkAuPX295O910fzP+YHrgPf4einMpOevlfz97gv8Bjg3327atVJ2D9ZQFirtNfWT/ecu1Jr/+dHWltN6EXE1MLvu4f5y+AhwRkS8GhEzyC7qTVpRZ6v1kws0XjPQI7lExOMRMS3//gXgbrK193r6ehkgF+jh6wUgIl7Kv12Q7D/5s/H1UpQJ9Pi1ImlV4IPAibyRRdOulbIbWENZqLSXBHCppJsk7Zk/tmK88anLJ4BeXQW/vxxWZt6lQXrxGvqqsvt8nlTTXd1zueSfZn47cD2+XuaqyeW6/KGevl4kzSdpGtl1cUVE3EmPXy/9ZAI9fq0APwa+Dcypeaxp10rZDSzPoJ/XuyPi7cAHgK9I2rz2ycj6IXs+syHk0EsZHQusSXavsMeAowfYt2tzkbQ48Afg6xHxfO1zvXy95Ln8niyXF/D1QkTMiYgJZGsybiHpvXXP99z1UpDJRHr8WpG0A/BkRNxCcU/eqK+VshtYQ1motGdExGP5n/8C/kTWvfiEpJUAJL0JeLK6CivVXw5DXsi2G0XEk5Ej68bu65LumVwkLUDWuDotIs7JH+7566Uml9P7cvH18oaIeBb4C/AOfL0A82TyP75WeBfwYUnTgTOArSSdRhOvlbIbWHMXKpW0INlCpeeWfM62JGlRSUvk3y8GbAvcTpZH3wq6uwHnFB+h6/WXw7nApyQtKGlNYB3ghgrqq0T+F7zPx8iuGeiRXCQJOAm4KyKOqXmqp6+X/nLx9aLl+oa6JC0CvA+4hR6+XvrLpK8Rkeu5ayUiDoqI1SJiTeBTwOURsQtNvFYGW8l9VKKfhUrLPGcbWxH4U/bvIvMDv4mIv0q6CThL0h7ADOCT1ZXYGpLOALYElpP0CPB94AgKcoiIuySdBdwFvAZ8Of8fV9cpyCUBJkqaQNYVPR3oW+S3V3J5N/BZ4DZJt+SPHYivl6JcDgJ27vHr5U3AqZLmI+tAOC0iLssz6tXrpb9Mft3j10q9vvfYtH9bvNComZmZWZOVvtComZmZWa9xA8vMzMysydzAMjMzM2syN7DMzMzMmswNLDMzM7MmcwPLzMzMrMncwDKzlpK0lKS98u/fJOnsJh13sqRv5t+nkrZuxnHNzEbC62CZWUvlNyc+LyLe1uTjJsALETHQPdXMzFrCPVhm1mpHAG+WdIuksyTdDiDpc5LOkfRXSdMl7S3pW5L+IelaSUvn+71Z0oWSbpJ0laS31J9A0hRJH8+/n5H3bt38/9u7f9amojCO499H0ILFl+ArEAL+KYKjg5sZglvBxbmdLA5OIi66K3ToGxBcnBzEqRSXUtouUkpfgIhiydCheRxy0iYhFxI5DSLfz3LPvTkn554Mlx/nHnIiYndQPyIWI2IjIr6WPtpz/A0k/ecMWJLm7RlwmJk3gbWxz27Q3xdtCXgF/M7MW8AW8LjUWQdWMvNOaf92Qh/J+dYXCXzPzNvAO+Bpuf4c+JyZd4H7wJuIuFphfJJ0sXsRStIE0VAG+JKZXaAbEb+Aj+X6HtAqG6XfA96XfT0BrkzR54dy3AY6pfwAeBgRg8C1AFwHvk07EElqYsCS9C85GSr3hs579J9Xl4CfZfZrkqZFpYPvOWX0udfJzIO/vFdJauQrQknzdgxcm7FNAGTmMXAUEY8Aoq81Xm9Kn4DVs4YRTaFNkmZmwJI0V5n5A9gsi9tfM7pWangGarw8OF8GnkTEDrAPtBvaTOx+qM5L4HJZ+L4PvJh1LJLUxL9pkCRJqswZLEmSpMoMWJIkSZUZsCRJkiozYEmSJFVmwJIkSarMgCVJklSZAUuSJKkyA5YkSVJlfwA92RG2HwIvygAAAABJRU5ErkJggg==", "text/plain": [ "" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Convert to a Plotly object." ], "metadata": {} }, { "cell_type": "code", "execution_count": 25, "source": [ "pyplot(kmf2, ci=False)" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 25 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "
\n", "# Testing for Difference" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "It looks like DNA Type 2 is potentially more deadly, or more difficult to treat compared to Type 1. However, the difference between these survival curves still does not seem dramatic. It will be useful to perform a statistical test on the different DNA profiles to see if their survival rates are significantly different.\n", "\n", "Python's *lifelines* contains methods in `lifelines.statistics`, and the R package `survival` uses a function `survdiff()`. Both functions return a p-value from a chi-squared distribution.\n", "\n", "It turns out these two DNA types do not have significantly different survival rates." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Using R" ], "metadata": {} }, { "cell_type": "code", "execution_count": 31, "source": [ "%%R \n", "survdiff(Surv(time, delta) ~ type)" ], "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "Call:\n", "survdiff(formula = Surv(time, delta) ~ type)\n", "\n", " N Observed Expected (O-E)^2/E (O-E)^2/V\n", "type=1 52 31 36.6 0.843 2.79\n", "type=2 28 22 16.4 1.873 2.79\n", "\n", " Chisq= 2.8 on 1 degrees of freedom, p= 0.0949 \n" ] }, "metadata": {} } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Using Python" ], "metadata": {} }, { "cell_type": "code", "execution_count": 32, "source": [ "from lifelines.statistics import logrank_test\n", "summary_= logrank_test(T, T2, C, C2, alpha=99)\n", "\n", "print summary_" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "
\n", "# Estimating Hazard Rates\n", "\n", "### Using R" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "To estimate the hazard function, we compute the cumulative hazard function using the [Nelson-Aalen estimator](), defined as:\n", "\n", "$$\\hat{\\Lambda} (t) = \\sum_{t_i \\leq t} \\frac{d_i}{n_i}$$\n", "\n", "where $d_i$ is the number of deaths at time $t_i$ and $n_i$ is the number of susceptible individuals. Both R and Python modules use the same estimator. However, in R we will use the `-log` of the Fleming and Harrington estimator, which is equivalent to the Nelson-Aalen." ], "metadata": {} }, { "cell_type": "code", "execution_count": 33, "source": [ "%%R \n", "\n", "haz <- Surv(time[type==1], delta[type==1])\n", "haz.fit <- summary(survfit(haz ~ 1), type='fh')\n", "\n", "x <- c(haz.fit$time, 250)\n", "y <- c(-log(haz.fit$surv), 1.474)\n", "cum.haz <- data.frame(time=x, cumulative.hazard=y)\n", "\n", "p <- ggplot(cum.haz, aes(time, cumulative.hazard)) + geom_step() + theme_bw() + \n", " ggtitle('Nelson-Aalen Estimate')\n", "p" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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" }, "metadata": {} } ], "metadata": {} }, { "cell_type": "code", "execution_count": 23, "source": [ "%R p <- plot.ly(\"https://plotly.com/~rmdk/185/cumulativehazard-vs-time/\")\n", "# pass object to python kernel\n", "%R -o p \n", "\n", "# Render HTML\n", "HTML(p[0])" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 23 } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Using Python" ], "metadata": {} }, { "cell_type": "code", "execution_count": 26, "source": [ "from lifelines.estimation import NelsonAalenFitter\n", "\n", "naf = NelsonAalenFitter()\n", "naf.fit(T, event_observed=C)\n", "\n", "naf.plot(title='Nelson-Aalen Estimate')" ], "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 26 }, { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {} } ], "metadata": { "scrolled": true } }, { "cell_type": "code", "execution_count": 27, "source": [ "naf.plot(ci_force_lines=True, title='Nelson-Aalen Estimate')\n", "py_p = plt.gcf()\n", "\n", "pyplot(py_p, legend=False)" ], "outputs": [ { "output_type": "execute_result", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "execution_count": 27 } ], "metadata": {} }, { "cell_type": "code", "execution_count": 1, "source": [ "from IPython.display import display, HTML\n", "\n", "display(HTML(''))\n", "display(HTML(''))\n", "\n", "! pip install publisher --upgrade\n", "import publisher\n", "publisher.publish(\n", " 'survival_analysis.ipynb', 'ipython-notebooks/survival-analysis-r-vs-python/',\n", " 'Survival Analysis with Plotly: R vs Python', \n", " 'An introduction to survival analysis with Plotly graphs using R, Python, and IPython notebooks',\n", " name='Survival Analysis with Plotly')" ], "outputs": [ { "output_type": "display_data", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Requirement already up-to-date: publisher in /Users/chelsea/venv/venv2.7/lib/python2.7/site-packages\r\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/Users/chelsea/venv/venv2.7/lib/python2.7/site-packages/IPython/nbconvert.py:13: ShimWarning: The `IPython.nbconvert` package has been deprecated since IPython 4.0. You should import from nbconvert instead.\n", " \"You should import from nbconvert instead.\", ShimWarning)\n", "/Users/chelsea/venv/venv2.7/lib/python2.7/site-packages/publisher/publisher.py:53: UserWarning: Did you \"Save\" this notebook before running this command? Remember to save, always save.\n", " warnings.warn('Did you \"Save\" this notebook before running this command? '\n" ] } ], "metadata": {} }, { "cell_type": "code", "execution_count": null, "source": [], "outputs": [], "metadata": { "collapsed": true } } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "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.10" } }, "nbformat": 4, "nbformat_minor": 1 }