def survival():
for u in range(len(User_dic)):
User = User_dic[u]
SubD = D[User]
flag = len(np.shape(SubD))
if flag == 1:
N[User] = 1
T = SubD[0] - min_time
S = SubD[2]
elif flag == 2:
I = np.shape(SubD)[0]
N[User] = I
T = np.zeros(np.shape(SubD)[0])
S = SubD[:,2]
for i in range(I):
T[i] = SubD[i,0] - min_time
else:
print 'err'
fig = plt.figure(figsize=(16,9))
plt.title('User' + str(User))
plt.xlabel('time')
plot_lifetimes(S, birthtimes=T)
fig.savefig('survival_u/survival_User' + str(User) + '.png')
def plot_lifetimes_for_diagnosis(df, diagnosis, current_time=50, subset_size=80):
df = df.loc[df['diagnosis'] == diagnosis]
# create figure and axes
fig, ax = plt.subplots()
# specify type for PyCharm help
fig: plt.Figure = fig
ax: plt.Axes = ax
if df.shape[0] >= subset_size:
df = df.sample(n=subset_size, random_state=1)
start_times, end_times = df['start_date'], df['end_date']
actual_lifetimes, death_observed = datetimes_to_durations(start_times, end_times, freq='M')
plot_lifetimes(durations=actual_lifetimes, event_observed=death_observed, ax=ax)
ax.set_title(diagnosis_list[diagnosis])
ax.set_xlabel('Čas od začátku sledování po vznik události v měsících')
ax.set_ylabel('Sledovaná osoba')
# show and save plot
fig.show()
fig.savefig(f'paper/img/image_{next(GEN)}.pdf', format='pdf')
def test_plot_lifetimes_relative(self, block):
self.plt.figure()
t = np.linspace(0, 20, 1000)
hz, coef, covrt = generate_hazard_rates(1, 5, t)
N = 20
T, C = generate_random_lifetimes(hz, t, size=N, censor=True)
plot_lifetimes(T, event_observed=C, block=block)
def test_plot_lifetimes_calendar(self, block):
self.plt.figure()
t = np.linspace(0, 20, 1000)
hz, coef, covrt = generate_hazard_rates(1, 5, t)
N = 20
current = 10
birthtimes = current * np.random.uniform(size=(N,))
T, C = generate_random_lifetimes(hz, t, size=N, censor=current - birthtimes)
plot_lifetimes(T, event_observed=C, birthtimes=birthtimes, block=block)
def test_MACS_data_with_plot_lifetimes(self, block):
df = load_multicenter_aids_cohort_study()
plot_lifetimes(
df["T"] - df["W"],
event_observed=df["D"],
entry=df["W"],
event_observed_color="#383838",
event_censored_color="#383838",
left_truncated=True,
)
self.plt.ylabel("Patient Number")
self.plt.xlabel("Years from AIDS diagnosis")
self.plt.title("test_MACS_data_with_plot_lifetimes")
self.plt.show(block=block)
def dump(self):
fig, ax = plt.subplots()
ax = plot_lifetimes( self.df[ json.loads( self.cols["x"] )[0] ] ,\
event_observed=self.df[ json.loads( self.cols["y"] )[0] ] )
ax.set_xlabel("day")
ax.set_ylabel("survive start and stop")
return fig
def test_plot_lifetimes_calendar(self, block, waltons):
T, E = waltons["T"], waltons["E"]
current = 10
birthtimes = current * np.random.uniform(size=(T.shape[0],))
ax = plot_lifetimes(T, event_observed=E, entry=birthtimes)
assert ax is not None
self.plt.title("test_plot_lifetimes_calendar")
self.plt.show(block=block)
def test_plot_lifetimes_relative(self, block):
t = np.linspace(0, 20, 1000)
hz, coef, covrt = generate_hazard_rates(1, 5, t)
N = 20
T, C = generate_random_lifetimes(hz, t, size=N, censor=True)
ax = plot_lifetimes(T, event_observed=C)
assert ax is not None
self.plt.title("test_plot_lifetimes_relative")
self.plt.show(block=block)
def test_plot_lifetimes_left_truncation(self, block, waltons):
T, E = waltons["T"], waltons["E"]
N = 20
current = 10
birthtimes = current * np.random.uniform(size=(T.shape[0],))
ax = plot_lifetimes(T, event_observed=E, entry=birthtimes, left_truncated=True)
assert ax is not None
self.plt.title("test_plot_lifetimes_left_truncation")
self.plt.show(block=block)
def test_plot_lifetimes_left_truncation(self, block):
t = np.linspace(0, 20, 1000)
hz, coef, covrt = generate_hazard_rates(1, 5, t)
N = 20
current = 10
birthtimes = current * np.random.uniform(size=(N,))
T, C = generate_random_lifetimes(hz, t, size=N, censor=current - birthtimes)
ax = plot_lifetimes(T, event_observed=C, entry=birthtimes, left_truncated=True)
assert ax is not None
self.plt.title("test_plot_lifetimes_left_truncation")
self.plt.show(block=block)
def survival():
for h in range(len(Hall_dic)):
Hall = Hall_dic[h]
SubPoint = Point_dic[Hall]
for p in range(len(SubPoint)):
Point = SubPoint[p]
SubD = D[Hall][Point]
T = np.zeros(np.shape(SubD)[0])
I = np.shape(SubD)[0]
N[Hall][Point] = I
for i in range(I):
T[i] = SubD[i][0] - min_time
S = SubD[:,2]
fig = plt.figure(figsize=(16,9))
plt.title('Hall' + str(Hall) + ' Point' + str(Point))
plt.xlabel('time')
plot_lifetimes(S, birthtimes=T)
fig.savefig('survival/survival_Hall' + str(Hall) + ' Point' +str(Point) + '.png')
def main():
# Generate some dummy data
np.set_printoptions(precision=2)
N = 20
study_duration = 12
# Note: a constant dropout rate is equivalent to an exponential distribution!
subsciption_list = [ [exponential(18), exponential(3)][uniform()<0.5] \
for i in range(N) ]
actual_subscriptiontimes = np.array(subsciption_list)
observed_subscriptiontimes = np.minimum(actual_subscriptiontimes,study_duration)
observed= actual_subscriptiontimes < study_duration
# Show the data
setFonts(18)
plt.xlim(0,24)
plt.vlines(12, 0, 30, lw=2, linestyles="--")
plt.xlabel('time')
plt.title('Subscription Times, at $t=12$ months')
plot_lifetimes(observed_subscriptiontimes, event_observed=observed)
plt.show()
print(f'Observed subscription time at time {study_duration:d}', \
observed_subscriptiontimes)
#slicing 100 observations to represent censorship
sns.set()
current_time = 40
sliced_lifetimes = data['Duration']
actual_observations = np.random.choice(sliced_lifetimes, 50)
observed_lifetime = np.minimum(actual_observations, current_time)
observed_lifetimes = observed_lifetime.tolist()
observed = actual_observations <= current_time
#Calling plot_esimate to visualize events
plt.xlim(0, 50)
plt.vlines(current_time, 0, 50, lw=2, linestyles='--')
plt.xlabel("Marital time (in years)")
plt.title("Divorce representation After " + str(current_time) + " Years")
sns.set()
plot_lifetimes(actual_observations, observed)
print("Observed divorces at %d:\n" % current_time, observed_lifetimes)
#Distribution of couples according to their marital duration
marital_duration = data.groupby('Duration')['Divorce'].count()
sns.set()
plt.plot(marital_duration, linewidth=3.0, color='crimson')
plt.xlabel("Years of Marriage")
plt.ylabel("Couples Getting Divorced")
plt.savefig(
'/home/raed/Dropbox/INSE - 6320/Final Project/Marriage_distribution.pdf')
plt.show()
# calculate the correlation matrix
corr = data.corr()
print(corr)
from lifelines.plotting import plot_lifetimes
from numpy.random import uniform, exponential
import numpy as np
import matplotlib.pylab as plt
N = 25
current_time = 10
actual_lifetimes = np.array([[exponential(12), exponential(2)][uniform() < 0.5] for i in range(N)])
observed_lifetimes = np.minimum(actual_lifetimes, current_time)
observed = actual_lifetimes < current_time
plt.xlim(0, 25)
plt.vlines(10, 0, 30, lw=2, linestyles='--')
plt.xlabel("time")
plt.title("Births and deaths of our population, at $t=10$")
plot_lifetimes(observed_lifetimes, event_observed=observed)
print("Observed lifetimes at time %d:\n" % (current_time), observed_lifetimes)
'''
# author: Thomas Haslwanter, date: Jun-2015
import numpy as np
import matplotlib.pyplot as plt
from lifelines.plotting import plot_lifetimes
from numpy.random import uniform, exponential
# Generate some dummy data
np.set_printoptions(precision=2)
N = 20
study_duration = 12
# Note: a constant dropout rate is equivalent to an exponential distribution!
actual_subscriptiontimes = np.array([[exponential(18),
exponential(3)][uniform() < 0.5]
for i in range(N)])
observed_subscriptiontimes = np.minimum(actual_subscriptiontimes,
study_duration)
observed = actual_subscriptiontimes < study_duration
# Show the data
plt.xlim(0, 24)
plt.vlines(12, 0, 30, lw=2, linestyles="--")
plt.xlabel('time')
plt.title('Subscription Times, at $t=12$ months')
plot_lifetimes(observed_subscriptiontimes, event_observed=observed)
print("Observed subscription time at time %d:\n" % (study_duration),
observed_subscriptiontimes)
import numpy as np
import pandas as pd
import tensorflow as tf
from keras import backend as K
import matplotlib.pyplot as plt
from lifelines import CoxPHFitter
from lifelines.plotting import plot_lifetimes
from efrontf import efron_estimator_tf
# Dummy data:
observed_times = np.array([5, 1, 3, 7, 2, 5, 4, 1, 1])
censoring = np.array([1, 1, 0, 1, 1, 1, 1, 0, 1])
predicted_risk = np.array([0.1, 0.4, -0.2, 0.2, -0.3, 0.0, -0.1, 0.3, -0.4])
# Plotting:
plt.xlim(0, 10)
plt.xlabel("time")
plot_lifetimes(observed_times, event_observed=censoring)
# get likelihood value:
K.eval(
efron_estimator_tf(K.variable(observed_times), K.variable(censoring),
K.variable(predicted_risk)))
# done
from lifelines.plotting import plot_lifetimes
import numpy as np
from numpy.random import uniform, exponential
N = 25
CURRENT_TIME = 10
actual_lifetimes = np.array([
exponential(12) if (uniform() < 0.5) else exponential(2) for i in range(N)
])
actual_lifetimes
observed_lifetimes = np.minimum(actual_lifetimes, CURRENT_TIME)
observed_lifetimes
death_observed = actual_lifetimes < CURRENT_TIME
death_observed
ax = plot_lifetimes(observed_lifetimes, event_observed=death_observed)
ax.set_xlim(0, 25)
ax.vlines(10, 0, 30, lw=2, linestyles='--')
ax.set_xlabel("time")
ax.set_title("Births and deaths of our population, at $t=10$")
print("Observed lifetimes at time %d:\n" % (CURRENT_TIME), observed_lifetimes)
ax = plot_lifetimes(actual_lifetimes, event_observed=death_observed)
ax.vlines(10, 0, 30, lw=2, linestyles='--')
ax.set_xlim(0, 25)
def test_plot_lifetimes_relative(self, block, waltons):
T, E = waltons["T"], waltons["E"]
ax = plot_lifetimes(T, event_observed=E)
assert ax is not None
self.plt.title("test_plot_lifetimes_relative")
self.plt.show(block=block)
## example 2
import matplotlib.pylab as plt
%pylab
figsize(12.5,6)
from lifelines.plotting import plot_lifetimes
from numpy.random import uniform, exponential
N = 25
current_time = 10
actual_lifetimes = np.array([[exponential(12), exponential(2)][uniform()<0.5] for i in range(N)])
observed_lifetimes = np.minimum(actual_lifetimes,current_time)
observed= actual_lifetimes < current_time
plt.xlim(0,25)
plt.vlines(10,0,30,lw=2, linestyles="--")
plt.xlabel('time')
plt.title('Births and deaths of our population, at $t=10$')
plot_lifetimes(observed_lifetimes, censorship=observed)
print "Observed lifetimes at time %d:\n"% (current_time), observed_lifetimes
?plot_lifetimes
import patsy
sys.path.append(os.path.join('..', '..', 'Utilities'))
try:
# Import formatting commands if directory "Utilities" is available
from ISP_mystyle import setFonts
except ImportError:
# Ensure correct performance otherwise
def setFonts(*options):
return
# Generate some dummy data
np.set_printoptions(precision=2)
N = 20
study_duration = 12
# Note: a constant dropout rate is equivalent to an exponential distribution!
actual_subscriptiontimes = np.array([[exponential(18), exponential(3)][uniform()<0.5] for i in range(N)])
observed_subscriptiontimes = np.minimum(actual_subscriptiontimes,study_duration)
observed= actual_subscriptiontimes < study_duration
# Show the data
setFonts(18)
plt.xlim(0,24)
plt.vlines(12, 0, 30, lw=2, linestyles="--")
plt.xlabel('time')
plt.title('Subscription Times, at $t=12$ months')
plot_lifetimes(observed_subscriptiontimes, event_observed=observed)
print("Observed subscription time at time %d:\n"%(study_duration), observed_subscriptiontimes)
