def fit(self, event_times, censorship=None, timeline=None, label='NA-estimate', alpha=None, insert_0=True):
"""
Parameters:
event_times: an array, or pd.Series, of length n of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
censorship: an array, or pd.Series, of length n -- True if the the death was observed, False if the event
was lost (right-censored). Defaults all True if censorship==None
label: a string to name the column of the estimate.
alpha: the alpha value in the confidence intervals. Overrides the initializing
alpha for this call to fit only.
insert_0: add a leading 0 (if not present) in the timeline.
Returns:
self, with new properties like 'survival_function_'.
"""
if censorship is None:
self.censorship = np.ones(len(event_times), dtype=bool)
else:
self.censorship = np.array(censorship).copy().astype(bool)
self.event_times = survival_table_from_events(event_times, self.censorship)
if alpha is None:
alpha = self.alpha
if timeline is None:
self.timeline = self.event_times.index.values.copy().astype(float)
if insert_0 and self.timeline[0] > 0:
self.timeline = np.insert(self.timeline, 0, 0.)
else:
self.timeline = np.array(timeline).copy().astype(float)
cumulative_hazard_, cumulative_sq_ = _additive_estimate(self.event_times, self.timeline,
self._additive_f, self._variance_f)
# esimates
self.cumulative_hazard_ = pd.DataFrame(cumulative_hazard_, columns=[label])
self.confidence_interval_ = self._bounds(cumulative_sq_[:, None], alpha)
self._cumulative_sq = cumulative_sq_
# estimation functions
self.predict = _predict(self, "cumulative_hazard_", label)
self.subtract = _subtract(self, "cumulative_hazard_")
self.divide = _divide(self, "cumulative_hazard_")
# plotting
self.plot = plot_dataframes(self, "cumulative_hazard_")
self.plot_cumulative_hazard = self.plot
self.plot_hazard = plot_dataframes(self, 'hazard_')
return self
def fit(self, event_times, timeline=None, censorship=None, columns=['KM-estimate']):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
censorship: an (n,1) array of booleans -- True if the the death was observed, False if the event
was lost (right-censored). Defaults all True if censorship==None
Returns:
DataFrame with index either event_times or timelines (if not None), with
values as the NelsonAalen estimate
"""
#need to sort event_times
if censorship is None:
self.censorship = np.ones_like(event_times, dtype=bool) #why boolean?
else:
self.censorship = censorship.copy()
self.event_times = dataframe_from_events_censorship(event_times, self.censorship)
if timeline is None:
self.timeline = self.event_times.index.values.copy()
else:
self.timeline = timeline
log_surivial_function, cumulative_sq_ = _additive_estimate(self.event_times, self.timeline,
self.censorship, self.additive_f,
0, columns )
self.survival_function_ = np.exp(log_surivial_function)
self.confidence_interval_ = self._bounds(cumulative_sq_)
self.plot = plot_dataframes(self, "survival_function_")
return self
def fit(self, event_times, timeline=None, censorship=None, columns=['NA-estimate']):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
Returns:
DataFrame with index either event_times or timelines (if not None), with
values as the NelsonAalen estimate
"""
if censorship is None:
self.censorship = np.ones_like(event_times, dtype=bool) #why boolean?
else:
self.censorship = censorship.copy()
self.event_times = dataframe_from_events_censorship(event_times, self.censorship)
if timeline is None:
self.timeline = self.event_times.index.values.copy()
else:
self.timeline = timeline
self.cumulative_hazard_, cumulative_sq_ = _additive_estimate(self.event_times,
self.timeline, self.censorship,
self.additive_f, 0, columns,
nelson_aalen_smoothing=self.nelson_aalen_smoothing )
self.confidence_interval_ = self._bounds(cumulative_sq_)
self.plot = plot_dataframes(self, "cumulative_hazard_")
return
def fit(self, event_times,censorship=None, timeline=None, columns=['NA-estimate'],alpha=None):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
columns: a length 1 array to name the column of the estimate.
alpha: the alpha value in the confidence intervals. Overrides the initializing
alpha for this call to fit only.
Returns:
DataFrame with index either event_times or timelines (if not None), with
values as the NelsonAalen estimate
"""
if censorship is None:
self.censorship = np.ones_like(event_times, dtype=bool) #why boolean?
else:
self.censorship = censorship.copy().astype(bool)
self.event_times = dataframe_from_events_censorship(event_times, self.censorship)
if alpha is None:
alpha = self.alpha
if timeline is None:
self.timeline = self.event_times.index.values.copy().astype(float)
else:
self.timeline = timeline
self.cumulative_hazard_, cumulative_sq_ = _additive_estimate(self.event_times,
self.timeline, self._additive_f,
columns, self._variance_f )
self.confidence_interval_ = self._bounds(cumulative_sq_,alpha)
self.plot = plot_dataframes(self, "cumulative_hazard_")
return
def fit(self, event_times,censorship=None, timeline=None, columns=['NA-estimate'], alpha=None, insert_0=True):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
columns: a length 1 array to name the column of the estimate.
alpha: the alpha value in the confidence intervals. Overrides the initializing
alpha for this call to fit only.
insert_0: add a leading 0 (if not present) in the timeline.
Returns:
DataFrame with index either event_times or timelines (if not None), with
values as the NelsonAalen estimate
"""
if censorship is None:
self.censorship = np.ones(event_times.shape[0], dtype=bool) #why boolean?
else:
self.censorship = np.array(censorship).copy().astype(bool)
self.event_times = survival_table_from_events(event_times, self.censorship)
if alpha is None:
alpha = self.alpha
if timeline is None:
self.timeline = self.event_times.index.values.copy().astype(float)
if insert_0 and self.timeline[0]>0:
self.timeline = np.insert(self.timeline,0,0.)
else:
self.timeline = timeline.astype(float)
cumulative_hazard_, cumulative_sq_ = _additive_estimate(self.event_times, self.timeline,
self._additive_f, self._variance_f )
self.cumulative_hazard_ = pd.DataFrame(cumulative_hazard_, columns=columns)
self.confidence_interval_ = self._bounds(cumulative_sq_[:,None],alpha)
self.plot = plot_dataframes(self, "cumulative_hazard_")
self.plot_cumulative_hazard = self.plot
self.plot_hazard = plot_dataframes(self, 'hazard_')
self._cumulative_sq = cumulative_sq_
return self
def fit(self, event_times, censorship=None, timeline=None, columns=['KM-estimate'], alpha=None, insert_0=True):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
censorship: an (n,1) array of booleans -- True if the the death was observed, False if the event
was lost (right-censored). Defaults all True if censorship==None
columns: a length 1 array to name the column of the estimate.
alpha: the alpha value in the confidence intervals. Overrides the initializing
alpha for this call to fit only.
insert_0: add a leading 0 (if not present) in the timeline.
Returns:
DataFrame with index either event_times or timelines (if not None), with
values under column_name with the KaplanMeier estimate
"""
#set to all observed if censorship is none
if censorship is None:
self.censorship = np.ones(event_times.shape[0], dtype=bool) #why boolean?
else:
self.censorship = np.array(censorship).copy()
if not alpha:
alpha = self.alpha
self.event_times = survival_table_from_events(event_times, self.censorship)
if timeline is None:
self.timeline = self.event_times.index.values.copy().astype(float)
if insert_0 and self.timeline[0]>0:
self.timeline = np.insert(self.timeline,0,0.)
else:
self.timeline = timeline.astype(float)
log_survival_function, cumulative_sq_ = _additive_estimate(self.event_times, self.timeline,
self._additive_f, self._additive_var)
self.survival_function_ = pd.DataFrame(np.exp(log_survival_function), columns=columns)
#self.median_ = median_survival_times(self.survival_function_)
self.confidence_interval_ = self._bounds(cumulative_sq_[:,None],alpha)
self.plot = plot_dataframes(self, "survival_function_")
self.plot_survival_function = self.plot
self.median_ = median_survival_times(self.survival_function_)
return self
def fit(self, event_times, censorship=None, timeline=None, columns=['KM-estimate'], alpha=None):
"""
Parameters:
event_times: an (n,1) array of times that the death event occured at
timeline: return the best estimate at the values in timelines (postively increasing)
censorship: an (n,1) array of booleans -- True if the the death was observed, False if the event
was lost (right-censored). Defaults all True if censorship==None
columns: a length 1 array to name the column of the estimate.
alpha: the alpha value in the confidence intervals. Overrides the initializing
alpha for this call to fit only.
Returns:
DataFrame with index either event_times or timelines (if not None), with
values under column_name with the KaplanMeier estimate
"""
#set to all observed if censorship is none
if censorship is None:
self.censorship = np.ones_like(event_times, dtype=bool) #why boolean?
else:
self.censorship = censorship.copy()
if not alpha:
alpha = self.alpha
self.event_times = dataframe_from_events_censorship(event_times, self.censorship)
if timeline is None:
self.timeline = self.event_times.index.values.copy()
else:
self.timeline = timeline
log_surivial_function, cumulative_sq_ = _additive_estimate(self.event_times,
self.timeline, self._additive_f,
columns, self._variance_f )
self.survival_function_ = np.exp(log_surivial_function)
self.median_ = median_survival_times(self.survival_function_)
self.confidence_interval_ = self._bounds(cumulative_sq_,alpha)
self.plot = plot_dataframes(self, "survival_function_")
return self
