lifelines 0.27.8__py3-none-any.whl → 0.29.0__py3-none-any.whl

lifelines/datasets/__init__.py

@@ -54,7 +54,7 @@ def load_multicenter_aids_cohort_study(**kwargs):
     """
     Originally in [1]::
 
-        Siz: (78, 4)
+        Size: (78, 4)
 
         AIDSY: date of AIDS diagnosis
         W: years from AIDS diagnosis to study entry

lifelines/exceptions.py

@@ -5,6 +5,10 @@ class StatError(Exception):
     pass
 
 
+class ProportionalHazardAssumptionError(Exception):
+    pass
+
+
 class ConvergenceError(ValueError):
     # inherits from ValueError for backwards compatibility reasons
     def __init__(self, msg, original_exception=""):

lifelines/fitters/__init__.py

@@ -18,7 +18,7 @@ from autograd.misc import flatten
 import autograd.numpy as anp
 
 from scipy.optimize import minimize, root_scalar
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 from scipy import stats
 
 import pandas as pd
@@ -550,7 +550,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
             minimizing_results, previous_results, minimizing_ll = None, None, np.inf
             for method, option in zip(
                 ["Nelder-Mead", self._scipy_fit_method],
-                [{"maxiter": 100}, {**{"disp": show_progress}, **self._scipy_fit_options, **fit_options}],
+                [{"maxiter": 400}, {**{"disp": show_progress}, **self._scipy_fit_options, **fit_options}],
             ):
 
                 initial_value = self._initial_values if previous_results is None else utils._to_1d_array(previous_results.x)
@@ -573,7 +573,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
 
             # convergence successful.
             # I still need to check for ~np.isnan(minimizing_results.x).any() since minimize will happily
-            # return nans even when criteria is satisified.
+            # return nans even when criteria is satisfied.
             if minimizing_results and minimizing_results.success and ~np.isnan(minimizing_results.x).any():
                 sol = utils._to_1d_array(minimizing_results.x)
                 # pylint: disable=no-value-for-parameter
@@ -876,7 +876,7 @@ class ParametricUnivariateFitter(UnivariateFitter):
           length n, the end of the period the subject experienced the event in. If the value is equal to the corresponding value in lower_bound, then
           the individual's event was observed (not censored).
         event_observed: numpy array or pd.Series, optional
-          length n, if left optional, infer from ``lower_bound`` and ``upper_cound`` (if lower_bound==upper_bound then event observed, if lower_bound < upper_bound, then event censored)
+          length n, if left optional, infer from ``lower_bound`` and ``upper_bound`` (if lower_bound==upper_bound then event observed, if lower_bound < upper_bound, then event censored)
         timeline: list, optional
             return the estimate at the values in timeline (positively increasing)
         label: string, optional
@@ -1409,7 +1409,7 @@ class ParametricRegressionFitter(RegressionFitter):
     def _survival_function(self, params, T, Xs):
         return anp.clip(anp.exp(-self._cumulative_hazard(params, T, Xs)), 1e-12, 1 - 1e-12)
 
-    def _log_likelihood_right_censoring(self, params, Ts, E, W, entries, Xs) -> float:
+    def _log_likelihood_right_censoring(self, params, Ts: tuple, E, W, entries, Xs) -> float:
 
         T = Ts[0]
         non_zero_entries = entries > 0
@@ -1925,7 +1925,7 @@ class ParametricRegressionFitter(RegressionFitter):
     def _fit_model(
         self, likelihood, Ts, Xs, E, weights, entries, fit_options, show_progress=False, user_supplied_initial_point=None
     ):
-        inital_points_as_arrays, unflatten_array_to_dict = self._prepare_initial_points(
+        initial_points_as_arrays, unflatten_array_to_dict = self._prepare_initial_points(
             user_supplied_initial_point, Ts, E, entries, weights, Xs
         )
 
@@ -1939,7 +1939,7 @@ class ParametricRegressionFitter(RegressionFitter):
 
         minimum_ll = np.inf
         minimum_results = None
-        for _initial_point in inital_points_as_arrays:
+        for _initial_point in initial_points_as_arrays:
 
             if _initial_point.shape[0] != Xs.columns.size:
                 raise ValueError("initial_point is not the correct shape.")
@@ -2507,7 +2507,7 @@ class ParametricRegressionFitter(RegressionFitter):
         warnings.warn("""Approximating the expected value using trapezoid rule.\n""", exceptions.ApproximationWarning)
         subjects = utils._get_index(X)
         v = self.predict_survival_function(X, conditional_after=conditional_after)[subjects]
-        return pd.Series(trapz(v.values.T, v.index), index=subjects).squeeze()
+        return pd.Series(trapezoid(v.values.T, v.index), index=subjects).squeeze()
 
     @property
     def median_survival_time_(self):
@@ -3365,6 +3365,8 @@ class ParametericAFTRegressionFitter(ParametricRegressionFitter):
             also display the baseline survival, defined as the survival at the mean of the original dataset.
         times: iterable
             pass in a times to plot
+        y: str
+            one of "survival_function", "hazard", "cumulative_hazard". Default "survival_function"
         kwargs:
             pass in additional plotting commands
 

lifelines/fitters/aalen_additive_fitter.py

@@ -6,7 +6,7 @@ import time
 import numpy as np
 import pandas as pd
 from numpy.linalg import LinAlgError
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 
 from lifelines.fitters import RegressionFitter
 from lifelines.utils.printer import Printer
@@ -396,7 +396,7 @@ It's important to know that the naive variance estimates of the coefficients are
         """
         index = _get_index(X)
         t = self._index
-        return pd.Series(trapz(self.predict_survival_function(X)[index].values.T, t), index=index)
+        return pd.Series(trapezoid(self.predict_survival_function(X)[index].values.T, t), index=index)
 
     def _compute_confidence_intervals(self):
         ci = 100 * (1 - self.alpha)

lifelines/fitters/breslow_fleming_harrington_fitter.py

@@ -72,7 +72,14 @@ class BreslowFlemingHarringtonFitter(NonParametricUnivariateFitter):
         alpha = coalesce(alpha, self.alpha)
 
         naf = NelsonAalenFitter(alpha=alpha)
-        naf.fit(durations, event_observed=event_observed, timeline=timeline, label=self._label, entry=entry, ci_labels=ci_labels)
+        naf.fit(
+            durations,
+            event_observed=event_observed,
+            timeline=timeline,
+            label=self._label,
+            entry=entry,
+            ci_labels=ci_labels,
+        )
         self.durations, self.event_observed, self.timeline, self.entry, self.event_table, self.weights = (
             naf.durations,
             naf.event_observed,
@@ -87,6 +94,7 @@ class BreslowFlemingHarringtonFitter(NonParametricUnivariateFitter):
         self.confidence_interval_ = np.exp(-naf.confidence_interval_)
         self.confidence_interval_survival_function_ = self.confidence_interval_
         self.confidence_interval_cumulative_density = 1 - self.confidence_interval_
+        self.confidence_interval_cumulative_density[:] = np.fliplr(self.confidence_interval_cumulative_density.values)
 
         # estimation methods
         self._estimation_method = "survival_function_"

lifelines/fitters/cox_time_varying_fitter.py

@@ -801,7 +801,7 @@ See https://stats.stackexchange.com/questions/11109/how-to-deal-with-perfect-sep
             hazards = self.predict_partial_hazard(tv_data).values
 
         unique_death_times = np.unique(stop[events.values])
-        baseline_hazard_ = pd.DataFrame(np.zeros_like(unique_death_times), index=unique_death_times, columns=["baseline hazard"])
+        baseline_hazard_ = pd.DataFrame(np.zeros_like(unique_death_times).astype(float), index=unique_death_times, columns=["baseline hazard"])
 
         for t in unique_death_times:
             ix = (start.values < t) & (t <= stop.values)

lifelines/fitters/coxph_fitter.py

@@ -9,7 +9,7 @@ import time
 from numpy import dot, einsum, log, exp, zeros, arange, multiply, ndarray
 import numpy as np
 from scipy.linalg import solve as spsolve, LinAlgError, norm, inv
-from scipy.integrate import trapz
+from scipy.integrate import trapezoid
 from scipy import stats
 from pandas import DataFrame, Series, Index
 import pandas as pd
@@ -80,7 +80,7 @@ class CoxPHFitter(RegressionFitter, ProportionalHazardMixin):
         When ``baseline_estimation_method="spline"``, this allows customizing the points in the time axis for the baseline hazard curve.
         To use evenly-spaced points in time, the ``n_baseline_knots`` parameter can be employed instead.
 
-      breakpoints: int
+      breakpoints: list, optional
         Used when ``baseline_estimation_method="piecewise"``. Set the positions of the baseline hazard breakpoints.
 
     Examples
@@ -2514,7 +2514,7 @@ See https://stats.stackexchange.com/q/11109/11867 for more.\n",
         """
         subjects = utils._get_index(X)
         v = self.predict_survival_function(X, conditional_after=conditional_after)[subjects]
-        return pd.Series(trapz(v.values.T, v.index), index=subjects)
+        return pd.Series(trapezoid(v.values.T, v.index), index=subjects)
 
     def _compute_baseline_hazard(self, partial_hazards: DataFrame, name: Any) -> pd.DataFrame:
         # https://stats.stackexchange.com/questions/46532/cox-baseline-hazard
@@ -3223,7 +3223,7 @@ class ParametricPiecewiseBaselinePHFitter(ParametricCoxModelFitter, Proportional
 
             for stratum, stratified_X in df.groupby(self.strata):
                 log_lambdas_ = anp.array(
-                    [0] + [self.params_[self._strata_labeler(stratum, i)][0] for i in range(2, self.n_breakpoints + 2)]
+                    [0] + [self.params_.loc[self._strata_labeler(stratum, i)].iloc[0] for i in range(2, self.n_breakpoints + 2)]
                 )
                 lambdas_ = np.exp(log_lambdas_)
 
@@ -3237,7 +3237,9 @@ class ParametricPiecewiseBaselinePHFitter(ParametricCoxModelFitter, Proportional
             return cumulative_hazard
 
         else:
-            log_lambdas_ = np.array([0] + [self.params_[param][0] for param in self._fitted_parameter_names if param != "beta_"])
+            log_lambdas_ = np.array(
+                [0] + [self.params_.loc[param].iloc[0] for param in self._fitted_parameter_names if param != "beta_"]
+            )
             lambdas_ = np.exp(log_lambdas_)
 
             Xs = self.regressors.transform_df(df)

lifelines/fitters/generalized_gamma_fitter.py

@@ -105,6 +105,7 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
     """
 
     _scipy_fit_method = "SLSQP"
+    _scipy_fit_options = {"maxiter": 10_000, "maxfev": 10_000}
     _fitted_parameter_names = ["mu_", "ln_sigma_", "lambda_"]
     _bounds = [(None, None), (None, None), (None, None)]
     _compare_to_values = np.array([0.0, 0.0, 1.0])
@@ -117,14 +118,14 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
         elif CensoringType.is_interval_censoring(self):
             # this fails if Ts[1] == Ts[0], so we add a some fudge factors.
             log_data = log(Ts[1] - Ts[0] + 0.1)
-        return np.array([log_data.mean(), log(log_data.std() + 0.01), 0.1])
+        return np.array([log_data.mean() * 1.5, log(log_data.std() + 0.1), 1.0])
 
     def _cumulative_hazard(self, params, times):
         mu_, ln_sigma_, lambda_ = params
 
         sigma_ = safe_exp(ln_sigma_)
         Z = (log(times) - mu_) / sigma_
-        ilambda_2 = 1 / lambda_ ** 2
+        ilambda_2 = 1 / lambda_**2
         clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e20)
 
         if lambda_ > 0:
@@ -137,7 +138,7 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
 
     def _log_hazard(self, params, times):
         mu_, ln_sigma_, lambda_ = params
-        ilambda_2 = 1 / lambda_ ** 2
+        ilambda_2 = 1 / lambda_**2
         Z = (log(times) - mu_) / safe_exp(ln_sigma_)
         clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e20)
         if lambda_ > 0:
@@ -171,5 +172,5 @@ class GeneralizedGammaFitter(KnownModelParametricUnivariateFitter):
         sigma_ = exp(self.ln_sigma_)
 
         if lambda_ > 0:
-            return exp(sigma_ * log(gammainccinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
-        return exp(sigma_ * log(gammaincinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
+            return exp(sigma_ * log(gammainccinv(1 / lambda_**2, p) * lambda_**2) / lambda_) * exp(self.mu_)
+        return exp(sigma_ * log(gammaincinv(1 / lambda_**2, p) * lambda_**2) / lambda_) * exp(self.mu_)

lifelines/fitters/kaplan_meier_fitter.py

@@ -351,9 +351,14 @@ class KaplanMeierFitter(NonParametricUnivariateFitter):
         primary_estimate_name = "survival_function_"
         secondary_estimate_name = "cumulative_density_"
 
-        (self.durations, self.event_observed, self.timeline, self.entry, self.event_table, self.weights) = _preprocess_inputs(
-            durations, event_observed, timeline, entry, weights
-        )
+        (
+            self.durations,
+            self.event_observed,
+            self.timeline,
+            self.entry,
+            self.event_table,
+            self.weights,
+        ) = _preprocess_inputs(durations, event_observed, timeline, entry, weights)
 
         alpha = alpha if alpha else self.alpha
         log_estimate, cumulative_sq_ = _additive_estimate(
@@ -386,6 +391,7 @@ class KaplanMeierFitter(NonParametricUnivariateFitter):
 
         self.confidence_interval_survival_function_ = self.confidence_interval_
         self.confidence_interval_cumulative_density_ = 1 - self.confidence_interval_
+        self.confidence_interval_cumulative_density_[:] = np.fliplr(self.confidence_interval_cumulative_density_.values)
         self._median = median_survival_times(self.survival_function_)
         self._cumulative_sq_ = cumulative_sq_
 

lifelines/fitters/mixins.py

@@ -4,6 +4,7 @@ from textwrap import dedent, fill
 from autograd import numpy as anp
 import numpy as np
 from pandas import DataFrame, Series
+from lifelines.exceptions import ProportionalHazardAssumptionError
 from lifelines.statistics import proportional_hazard_test, TimeTransformers
 from lifelines.utils import format_p_value
 from lifelines.utils.lowess import lowess
@@ -28,6 +29,7 @@ class ProportionalHazardMixin:
         p_value_threshold: float = 0.01,
         plot_n_bootstraps: int = 15,
         columns: Optional[List[str]] = None,
+        raise_on_fail: bool = False,
     ) -> None:
         """
         Use this function to test the proportional hazards assumption. See usage example at
@@ -51,6 +53,8 @@ class ProportionalHazardMixin:
             the function significantly.
         columns: list, optional
             specify a subset of columns to test.
+        raise_on_fail: bool, optional
+            throw a ``ProportionalHazardAssumptionError`` if the test fails. Default: False.
 
         Returns
         --------
@@ -106,8 +110,8 @@ class ProportionalHazardMixin:
         axes = []
 
         for variable in self.params_.index.intersection(columns or self.params_.index):
-            minumum_observed_p_value = test_results.summary.loc[variable, "p"].min()
-            
+            minimum_observed_p_value = test_results.summary.loc[variable, "p"].min()
+
             # plot is done (regardless of test result) whenever `show_plots = True`
             if show_plots:
                 axes.append([])
@@ -150,7 +154,7 @@ class ProportionalHazardMixin:
                 plt.tight_layout()
                 plt.subplots_adjust(top=0.90)
 
-            if np.round(minumum_observed_p_value, 2) > p_value_threshold:
+            if np.round(minimum_observed_p_value, 2) > p_value_threshold:
                 continue
 
             counter += 1
@@ -178,7 +182,7 @@ class ProportionalHazardMixin:
             print()
             print(
                 "%d. Variable '%s' failed the non-proportional test: p-value is %s."
-                % (counter, variable, format_p_value(4)(minumum_observed_p_value)),
+                % (counter, variable, format_p_value(4)(minimum_observed_p_value)),
                 end="\n\n",
             )
 
@@ -224,9 +228,8 @@ class ProportionalHazardMixin:
                         ),
                         end="\n\n",
                     )
-#################
+        #################
 
-            
         if advice and counter > 0:
             print(
                 dedent(
@@ -243,6 +246,8 @@ class ProportionalHazardMixin:
 
         if counter == 0:
             print("Proportional hazard assumption looks okay.")
+        elif raise_on_fail:
+            raise ProportionalHazardAssumptionError()
         return axes
 
     @property

lifelines/fitters/nelson_aalen_fitter.py

@@ -183,7 +183,7 @@ class NelsonAalenFitter(UnivariateFitter):
         )
 
     def _variance_f_discrete(self, population, deaths):
-        return (population - deaths) * deaths / population ** 3
+        return (1 - deaths / population) * (deaths / population) * (1.0 / population)
 
     def _additive_f_smooth(self, population, deaths):
         cum_ = np.cumsum(1.0 / np.arange(1, np.max(population) + 1))
@@ -200,7 +200,7 @@ class NelsonAalenFitter(UnivariateFitter):
         Parameters
         -----------
         bandwidth: float
-            the bandwith used in the Epanechnikov kernel.
+            the bandwidth used in the Epanechnikov kernel.
 
         Returns
         -------
@@ -239,7 +239,7 @@ class NelsonAalenFitter(UnivariateFitter):
         C = var_hazard_.values != 0.0  # only consider the points with jumps
         std_hazard_ = np.sqrt(
             1.0
-            / (bandwidth ** 2)
+            / (bandwidth**2)
             * np.dot(epanechnikov_kernel(timeline[:, None], timeline[C][None, :], bandwidth) ** 2, var_hazard_.values[C])
         )
         values = {

lifelines/fitters/npmle.py

@@ -291,7 +291,7 @@ def reconstruct_survival_function(
 
     # First backfill at events between known observations
     # Second fill all events _outside_ known obs with running_sum
-    return full_dataframe.combine_first(df).bfill().fillna(running_sum).clip(lower=0.0)
+    return full_dataframe.combine_first(df).astype(float).bfill().fillna(running_sum).clip(lower=0.0)
 
 
 def npmle_compute_confidence_intervals(left, right, mle_, alpha=0.05, samples=1000):

lifelines/fitters/piecewise_exponential_regression_fitter.py

@@ -66,7 +66,7 @@ class PiecewiseExponentialRegressionFitter(ParametricRegressionFitter):
         coef_penalty = 0
         if self.penalizer > 0:
             for i in range(params_stacked.shape[1]):
-                if not self._cols_to_not_penalize[i]:
+                if not self._cols_to_not_penalize.iloc[i]:
                     coef_penalty = coef_penalty + (params_stacked[:, i]).var()
 
         return neg_ll + self.penalizer * coef_penalty

lifelines/generate_datasets.py

@@ -5,7 +5,7 @@ import pandas as pd
 
 from scipy import stats
 from scipy.optimize import newton
-from scipy.integrate import cumtrapz
+from scipy.integrate import cumulative_trapezoid
 
 random = np.random
 
@@ -172,7 +172,7 @@ def constant_coefficients(d, timelines, constant=True, independent=0):
     timelines: the observational times
     constant: True for constant coefficients
     independent: the number of coffients to set to 0 (covariate is ind of survival), or
-      a list of covariates to make indepent.
+      a list of covariates to make independent.
 
     returns a matrix (t,d+1) of coefficients
     """
@@ -187,7 +187,7 @@ def time_varying_coefficients(d, timelines, constant=False, independent=0, randg
     timelines: the observational times
     constant: True for constant coefficients
     independent: the number of coffients to set to 0 (covariate is ind of survival), or
-      a list of covariates to make indepent.
+      a list of covariates to make independent.
     randgen: how scalar coefficients (betas) are sampled.
 
     returns a matrix (t,d+1) of coefficients
@@ -221,7 +221,7 @@ def generate_hazard_rates(n, d, timelines, constant=False, independent=0, n_bina
       n: the number of instances
       d: the number of covariates
       lifelines: the observational times
-      constant: make the coeffients constant (not time dependent)
+      constant: make the coefficients constant (not time dependent)
       n_binary: the number of binary covariates
       model: from ["aalen", "cox"]
 
@@ -253,7 +253,7 @@ def generate_random_lifetimes(hazard_rates, timelines, size=1, censor=None):
       timelines: (t,) the observation times
       size: the number to return, per hardard rate
       censor: If True, adds uniform censoring between timelines.max() and  0
-              If a postive number, censors all events above that value.
+              If a positive number, censors all events above that value.
               If (n,) np.array >=0 , censor elementwise.
 
 
@@ -308,7 +308,7 @@ def cumulative_integral(fx, x):
     fx: (n,d) numpy array, what you want to integral of
     x: (n,) numpy array, location to integrate over.
     """
-    return cumtrapz(fx.T, x, initial=0).T
+    return cumulative_trapezoid(fx.T, x, initial=0).T
 
 
 def construct_survival_curves(hazard_rates, timelines):

lifelines/utils/__init__.py

@@ -11,7 +11,7 @@ import warnings
 from numpy import ndarray
 import numpy as np
 
-from scipy.integrate import quad, trapz
+from scipy.integrate import quad, trapezoid
 from scipy.linalg import solve
 from scipy import stats
 
@@ -266,7 +266,7 @@ def _expected_value_of_survival_up_to_t(model_or_survival_function, t: float = n
         )
         sf = model_or_survival_function.loc[:t]
         sf = pd.concat((sf, pd.DataFrame([1], index=[0], columns=sf.columns))).sort_index()
-        return trapz(y=sf.values[:, 0], x=sf.index)
+        return trapezoid(y=sf.values[:, 0], x=sf.index)
     elif isinstance(model_or_survival_function, lifelines.fitters.UnivariateFitter):
         # lifelines model
         model = model_or_survival_function
@@ -311,9 +311,9 @@ def _expected_value_of_survival_squared_up_to_t(
 
     if isinstance(model_or_survival_function, pd.DataFrame):
         sf = model_or_survival_function.loc[:t]
-        sf = sf.append(pd.DataFrame([1], index=[0], columns=sf.columns)).sort_index()
+        sf = pd.concat((sf, pd.DataFrame([1], index=[0], columns=sf.columns))).sort_index()
         sf_tau = sf * sf.index.values[:, None]
-        return 2 * trapz(y=sf_tau.values[:, 0], x=sf_tau.index)
+        return 2 * trapezoid(y=sf_tau.values[:, 0], x=sf_tau.index)
     elif isinstance(model_or_survival_function, lifelines.fitters.UnivariateFitter):
         # lifelines model
         model = model_or_survival_function
@@ -556,12 +556,12 @@ def _group_event_table_by_intervals(event_table, intervals) -> pd.DataFrame:
 
         intervals = np.arange(0, event_max + bin_width, bin_width)
 
-    event_table = event_table.groupby(pd.cut(event_table["event_at"], intervals, include_lowest=True)).agg(
+    event_table = event_table.groupby(pd.cut(event_table["event_at"], intervals, include_lowest=True), observed=False).agg(
         {"removed": ["sum"], "observed": ["sum"], "censored": ["sum"], "at_risk": ["max"]}
     )
     # convert columns from multiindex
     event_table.columns = event_table.columns.droplevel(1)
-    return event_table.bfill()
+    return event_table.bfill().fillna(0)
 
 
 def survival_events_from_table(survival_table, observed_deaths_col="observed", censored_col="censored"):
@@ -648,7 +648,7 @@ def datetimes_to_durations(
         the units of time to use.  See Pandas 'freq'. Default 'D' for days.
     dayfirst: bool, optional (default=False)
         see Pandas `to_datetime`
-    na_values : list, optional
+    na_values : list[str], optional
         list of values to recognize as NA/NaN. Ex: ['', 'NaT']
     format:
         see Pandas `to_datetime`
@@ -679,7 +679,7 @@ def datetimes_to_durations(
     start_times = pd.Series(start_times).copy()
     end_times = pd.Series(end_times).copy()
 
-    C = ~(pd.isnull(end_times).values | end_times.isin(na_values or [""]))
+    C = ~(pd.isnull(end_times).values | end_times.astype(str).isin(na_values or [""]))
     end_times[~C] = fill_date_
     start_times_ = pd.to_datetime(start_times, dayfirst=dayfirst, format=format)
     end_times_ = pd.to_datetime(end_times, dayfirst=dayfirst, errors="coerce", format=format)
@@ -744,9 +744,6 @@ def k_fold_cross_validation(
     results: list
       (k,1) list of scores for each fold. The scores can be anything.
 
-    See Also
-    ---------
-    lifelines.utils.sklearn_adapter.sklearn_adapter
 
     """
     # Make sure fitters is a list
@@ -884,6 +881,7 @@ def _additive_estimate(events, timeline, _additive_f, _additive_var, reverse):
         population = events["at_risk"] - entrances
 
         estimate_ = np.cumsum(_additive_f(population, deaths))
+
         var_ = np.cumsum(_additive_var(population, deaths))
 
     timeline = sorted(timeline)
@@ -1466,7 +1464,7 @@ def add_covariate_to_timeline(
     cv = cv.sort_values([id_col, duration_col])
     cvs = cv.pipe(remove_redundant_rows).pipe(transform_cv_to_long_format).groupby(id_col, sort=True)
 
-    long_form_df = long_form_df.groupby(id_col, group_keys=False, sort=True).apply(expand, cvs=cvs)
+    long_form_df = long_form_df.groupby(id_col, group_keys=False, sort=True)[long_form_df.columns].apply(expand, cvs=cvs)
     return long_form_df.reset_index(drop=True)
 
 
@@ -1508,7 +1506,7 @@ def covariates_from_event_matrix(df, id_col) -> pd.DataFrame:
     """
     df = df.set_index(id_col)
     df = df.fillna(np.inf)
-    df = df.stack(dropna=False).reset_index()
+    df = df.stack(future_stack=True).reset_index()
     df.columns = [id_col, "event", "duration"]
     df["_counter"] = 1
     return (

lifelines/version.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-__version__ = "0.27.8"
+__version__ = "0.29.0"

{lifelines-0.27.8.dist-info → lifelines-0.29.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lifelines
-Version: 0.27.8
+Version: 0.29.0
 Summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
 Home-page: https://github.com/CamDavidsonPilon/lifelines
 Author: Cameron Davidson-Pilon
@@ -9,18 +9,16 @@ License: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy <2.0,>=1.14.0
-Requires-Dist: scipy >=1.2.0
-Requires-Dist: pandas >=1.0.0
+Requires-Dist: scipy >=1.7.0
+Requires-Dist: pandas >=2.1
 Requires-Dist: matplotlib >=3.0
 Requires-Dist: autograd >=1.5
 Requires-Dist: autograd-gamma >=0.3
@@ -52,8 +50,8 @@ If you are new to survival analysis, wondering why it is useful, or are interest
 
 ## Contact
  - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
- - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion)
- - creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
+ - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion).
+ - Creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
 
 ## Development
 

{lifelines-0.27.8.dist-info → lifelines-0.29.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 lifelines/__init__.py,sha256=F_sKrawq6L4GwTPgOu4FjoGUKQ2gfelAVIQOW1Ee8Ao,2241
 lifelines/calibration.py,sha256=Luii7bkJ2YB0jpuOYYhI22aUyEc1gLsS10Pno6Sqo98,4113
-lifelines/exceptions.py,sha256=Kf6GN2vB-SHde2mbPomj2PhpnCvCBOSTUZLY1jwOw-U,514
-lifelines/generate_datasets.py,sha256=WsvvrZt0jEYQ7-Fp53vrCq7MzmAM2pPUSoCaiQRwN5g,10155
+lifelines/exceptions.py,sha256=8T1vQuI6Fnf_5OfiJahksn5Soe-SmU9Y2IA7HYen460,577
+lifelines/generate_datasets.py,sha256=nwGVpkcVRKH70N8z0Z-y7GgetX8suZZ1FFmdjOB8tBs,10188
 lifelines/plotting.py,sha256=sQmwpSziHzVQoWoe_gll4LInrjg-E4FpeWMp07wurNo,35069
 lifelines/statistics.py,sha256=cOszUYz87elnbTAt6V3fTrHwPjB9HFI1hxjLvKypS6k,35129
-lifelines/version.py,sha256=i_7hf_ze0p4EVBems7NVh3EH_hYHAeUYD_J_LE6mR50,88
+lifelines/version.py,sha256=pYOd-rP1moJefUJJ6DbkYBuzORUtOVDOBiCBT13-usg,88
 lifelines/datasets/CuZn-LeftCensoredDataset.csv,sha256=PxTdZcJPPbhtaadpHjhMFVcUxmSn84BuDarujZIJpm4,1996
-lifelines/datasets/__init__.py,sha256=dhFp0uvLVBoAPBNSziknPpNc-ML9Ega6X2yL2UJHQ1M,19976
+lifelines/datasets/__init__.py,sha256=wiKbbNj-SSrgk_jysTdeQo1ceCmHXKje8WIzwBJAH_E,19977
 lifelines/datasets/anderson.csv,sha256=nTAtTK8mf0ymU88nKvO2Fj0WL9SE9o4S0GVujmX8Cl4,580
 lifelines/datasets/c_botulinum_lag_phase.csv,sha256=K3vda-75OqH-UxMAJIpYf0LldUZE5tiwch5ohP2v9Yw,386
 lifelines/datasets/canadian_senators.csv,sha256=nbpDx6e_fLmalLaS9aeWC-2EIsE850XsOZTpN_OWqn0,163046
@@ -35,39 +35,38 @@ lifelines/datasets/rossi.csv,sha256=AhRAAXDgfzAVooXtyiAUysDa6KrBJfy6rWQkkOBfiSw,
 lifelines/datasets/stanford_heart.csv,sha256=HWS9SqJjQ6gDmvxxKCJLR1cOIJ8XKuwTNu4bW8tKWVM,8859
 lifelines/datasets/static_test.csv,sha256=w2PtSkXknCZfciwqcOZGlA8znBO7jTcq_AJ5e6NStAk,101
 lifelines/datasets/waltons_dataset.csv,sha256=Fd4UX6tGYxgGhXtH3T-S81wIGIbVohv5yom4aw0kXL8,2449
-lifelines/fitters/__init__.py,sha256=_bW0VgluvRFHfd_wn4NX4nTqSL2F0O7V8YeK12rhpos,151518
-lifelines/fitters/aalen_additive_fitter.py,sha256=vRQb38weMcknyxC9bJwiALwCzxmJ5DsEZwHkz2zV93k,21518
+lifelines/fitters/__init__.py,sha256=a3ACmN8KANdg7uyZ36lSIMvUx0rZKB3HhvHdTgbQfP0,151648
+lifelines/fitters/aalen_additive_fitter.py,sha256=xca1uoNbuPS2YoGQ73GYa5JLZTLCt9otJPhhi2AJm4A,21526
 lifelines/fitters/aalen_johansen_fitter.py,sha256=w_2MV7Bbtr0swJ0VdySqirhlGsjbYyqduRx9iLKd6XA,14172
-lifelines/fitters/breslow_fleming_harrington_fitter.py,sha256=Te1Y73lIIKhTC6yMADe35RVHI4XOLF17ub-N8oudS4I,4091
-lifelines/fitters/cox_time_varying_fitter.py,sha256=i8_mmJZm0VjHnX7wZYeLwMgpJryr1hfd69iRwaBn33Q,34656
-lifelines/fitters/coxph_fitter.py,sha256=uv_e6wR0o3gyZcaNOYbeeZhgfaPXQhtcM-nc3-9kxAg,136853
+lifelines/fitters/breslow_fleming_harrington_fitter.py,sha256=_86qU3wMHEyuCKLjhHLERP_ymNnlSvi7chWgi8Kygxg,4293
+lifelines/fitters/cox_time_varying_fitter.py,sha256=cZo9opn4OdFajrj6aBxJDhgWvFIUHdsq7jpgMQ0HchU,34670
+lifelines/fitters/coxph_fitter.py,sha256=zbmwmO1EyHy-19ijuMkF_RCb7dG_VB7DBH7qArHar6w,136920
 lifelines/fitters/crc_spline_fitter.py,sha256=FUaiz4O-Hdke7T5dV8RCl-27oWxrMJLBSXxnRN4QkGQ,3126
 lifelines/fitters/exponential_fitter.py,sha256=Fbb1rtBOrHb_YxFYidzqXcFw7aWsqet_2vqi7s8WJ4U,2857
-lifelines/fitters/generalized_gamma_fitter.py,sha256=FUGff4DBhTqZ4woAhXpcH-YMF0L_CbdzGkAoT6TXcGI,6426
+lifelines/fitters/generalized_gamma_fitter.py,sha256=OiXO9onvYtI2gNvUoxF4mjEjbj7IRZl5R4UZ_RzrSjo,6482
 lifelines/fitters/generalized_gamma_regression_fitter.py,sha256=UzG3dVau0UNdQtM6yW63wabDf7j--rxrdE9AlaVB8Vk,7955
-lifelines/fitters/kaplan_meier_fitter.py,sha256=079URtbAAwae1SkzgTi-nCOhfJklfogMiOFiyUdUaYg,24027
+lifelines/fitters/kaplan_meier_fitter.py,sha256=UYPJi4BYcn54F26fc_lkkYzcZV-yUomsBB59ufdLRF8,24209
 lifelines/fitters/log_logistic_aft_fitter.py,sha256=cw179z0_IqvuWgOORHSZ1lBiidHcYkiO4hDi4YDEqRo,7074
 lifelines/fitters/log_logistic_fitter.py,sha256=iTH97i9TrLp5IVBIZHC8nx5rvSn2-KM-wfv1wR_YSPU,4004
 lifelines/fitters/log_normal_aft_fitter.py,sha256=aOcdMR8T4vhy2BKGebrpEJD_lTZIQQ5VsrnuuKkU0RA,7890
 lifelines/fitters/log_normal_fitter.py,sha256=NLn1DCxJ9WJrVaairJPcOu_lShko_-vwoXw6goRR42w,3557
-lifelines/fitters/mixins.py,sha256=6k5-g8cit8ODbU7PbVD9tfYsY0jpde0HID3wJQ5kz1k,12527
+lifelines/fitters/mixins.py,sha256=5s9FdxHUU0RxvFvmM77QmFiPmO7iyU7upzkF7BmWOec,12827
 lifelines/fitters/mixture_cure_fitter.py,sha256=UetFlv9EfFYMDt95M2iR354lna5RKeWtO_lkoaMmoZE,5416
-lifelines/fitters/nelson_aalen_fitter.py,sha256=UNlEX5wR6xsUmEmJ2n2MEqblz-KvGmvlh8eGHfuQf6Y,10666
-lifelines/fitters/npmle.py,sha256=HV3yeu1byVv5oBSdv5TuLUg2X5NUxydxj8-h_xYScB0,10143
+lifelines/fitters/nelson_aalen_fitter.py,sha256=C_hEuBwZfrYLbd6KNI34jEs-2B7Y3x2SIvp-HQGJW_Y,10687
+lifelines/fitters/npmle.py,sha256=K2PX1YWuygzwUa5H6I2w6CF8uqELJqb1KJEiN5dZbRI,10157
 lifelines/fitters/piecewise_exponential_fitter.py,sha256=j48sXaEODClFmfFP3THb0qJ3_Q7ctJz19j50Uo1QJME,3357
-lifelines/fitters/piecewise_exponential_regression_fitter.py,sha256=JuGm93cKQBu6KBTHEOoheLJfMqP0h1ckeQjMIpC8aQo,4978
+lifelines/fitters/piecewise_exponential_regression_fitter.py,sha256=kdnsm2oE1i_Sarxiw8lDcGEk8vachmNE8qCJdm3g_6U,4983
 lifelines/fitters/spline_fitter.py,sha256=TnkXPBabgZVqtI90T1-gm6C8k73WhQMrhbEAZw1OX0c,4214
 lifelines/fitters/weibull_aft_fitter.py,sha256=6wtU499AvXxZAE9PdnNQnbzh_NpPcdAEL6zd3xRV8hU,7772
 lifelines/fitters/weibull_fitter.py,sha256=CcII_V5ns00jP5sqv0dn8Yo0T3kdyc4Rkpb2bBuTvjU,3771
-lifelines/utils/__init__.py,sha256=e_hkwdPsn3SWoDyJeXoRh7oVU2TZwg2iSUUJZjoLKyM,70490
+lifelines/utils/__init__.py,sha256=IIn6YTAh98n8Jb7y1MZcHlAcrmO5XiVcu2nMrfJVMbE,70500
 lifelines/utils/btree.py,sha256=yevaIsGw_tQsGauXmwBHTMgCBjuuMZQgdHa-nCB-q2I,4369
 lifelines/utils/concordance.py,sha256=hWXrmg1BiK2Hqu9CRzlvkPlnlmZqZcAxH7L1PjaqdC8,12245
 lifelines/utils/lowess.py,sha256=MMydVcnbxqIgsiNcIgVUFtlFycD7v3ezwEGpituvBHs,2541
 lifelines/utils/printer.py,sha256=-nXxu02gs0kaKfoQQ65sH-I45tGmgoFeOOIUSEc53iE,5861
 lifelines/utils/safe_exp.py,sha256=HCCAkwQTx6G2qRC03v9Q_GWqVj8at1Eac1JVrMgS9hg,4350
-lifelines/utils/sklearn_adapter.py,sha256=S5qotbZ1hf1fhFBsx39Yd_NpA31jB9HhRiLjE8TWlhw,4202
-lifelines-0.27.8.dist-info/LICENSE,sha256=AasDeD139SnTdfXbKgN4BMyMgBlRy9YFs60tNrB4wf0,1079
-lifelines-0.27.8.dist-info/METADATA,sha256=_F3epTvxvgQlotdOsNhcL05k_jcDz3WofMBJE-xrXf0,3288
-lifelines-0.27.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-lifelines-0.27.8.dist-info/top_level.txt,sha256=3i57Z4mtpc6jWrsW0n-_o9Y7CpzytMTeLMPJBHYAo0o,10
-lifelines-0.27.8.dist-info/RECORD,,
+lifelines-0.29.0.dist-info/LICENSE,sha256=AasDeD139SnTdfXbKgN4BMyMgBlRy9YFs60tNrB4wf0,1079
+lifelines-0.29.0.dist-info/METADATA,sha256=JOhlJ11AqPSdC2P1z8KNg_Sh4mhCj9f7ymMBz85cZi8,3187
+lifelines-0.29.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+lifelines-0.29.0.dist-info/top_level.txt,sha256=3i57Z4mtpc6jWrsW0n-_o9Y7CpzytMTeLMPJBHYAo0o,10
+lifelines-0.29.0.dist-info/RECORD,,

{lifelines-0.27.8.dist-info → lifelines-0.29.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lifelines/utils/sklearn_adapter.py

@@ -1,135 +0,0 @@
-# -*- coding: utf-8 -*-
-import inspect
-import pandas as pd
-
-try:
-    from sklearn.base import BaseEstimator, RegressorMixin, MetaEstimatorMixin
-except ImportError:
-    raise ImportError("scikit-learn must be installed on the local system to use this utility class.")
-from . import concordance_index
-
-__all__ = ["sklearn_adapter"]
-
-
-def filter_kwargs(f, kwargs):
-    s = inspect.signature(f)
-    res = {k: kwargs[k] for k in s.parameters if k in kwargs}
-    return res
-
-
-class _SklearnModel(BaseEstimator, MetaEstimatorMixin, RegressorMixin):
-    def __init__(self, **kwargs):
-        self._params = kwargs
-        self.lifelines_model = self.lifelines_model(**filter_kwargs(self.lifelines_model.__init__, self._params))
-        self._params["duration_col"] = "duration_col"
-        self._params["event_col"] = self._event_col
-
-    @property
-    def _yColumn(self):
-        return self._params["duration_col"]
-
-    @property
-    def _eventColumn(self):
-        return self._params["event_col"]
-
-    def fit(self, X, y=None):
-        """
-
-        Parameters
-        -----------
-
-        X: DataFrame
-            must be a pandas DataFrame (with event_col included, if applicable)
-
-        """
-        if not isinstance(X, pd.DataFrame):
-            raise ValueError("X must be a DataFrame. Got type: {}".format(type(X)))
-
-        X = X.copy()
-
-        if y is not None:
-            X.insert(len(X.columns), self._yColumn, y, allow_duplicates=False)
-
-        fit = getattr(self.lifelines_model, self._fit_method)
-        self.lifelines_model = fit(df=X, **filter_kwargs(fit, self._params))
-        return self
-
-    def set_params(self, **params):
-        for key, value in params.items():
-            setattr(self.lifelines_model, key, value)
-        return self
-
-    def get_params(self, deep=True):
-        out = {}
-        for name, p in inspect.signature(self.lifelines_model.__init__).parameters.items():
-            if p.kind < 4:  # ignore kwargs
-                out[name] = getattr(self.lifelines_model, name)
-        return out
-
-    def predict(self, X, **kwargs):
-        """
-        Parameters
-        ------------
-        X: DataFrame or numpy array
-
-        """
-        predictions = getattr(self.lifelines_model, self._predict_method)(X, **kwargs).squeeze().values
-        return predictions
-
-    def score(self, X, y, **kwargs):
-        """
-
-        Parameters
-        -----------
-
-        X: DataFrame
-            must be a pandas DataFrame (with event_col included, if applicable)
-
-        """
-        rest_columns = list(set(X.columns) - {self._yColumn, self._eventColumn})
-
-        x = X.loc[:, rest_columns]
-        e = X.loc[:, self._eventColumn] if self._eventColumn else None
-
-        if y is None:
-            y = X.loc[:, self._yColumn]
-
-        if callable(self._scoring_method):
-            res = self._scoring_method(y, self.predict(x, **kwargs), event_observed=e)
-        else:
-            raise ValueError()
-        return res
-
-
-def sklearn_adapter(fitter, event_col=None, predict_method="predict_expectation", scoring_method=concordance_index):
-    """
-    This function wraps lifelines models into a scikit-learn compatible API. The function returns a
-    class that can be instantiated with parameters (similar to a scikit-learn class).
-
-    Parameters
-    ----------
-
-    fitter: class
-        The class (not an instance) to be wrapper. Example: ``CoxPHFitter`` or ``WeibullAFTFitter``
-    event_col: string
-        The column in your DataFrame that represents (if applicable) the event column
-    predict_method: string
-        Can be the string ``"predict_median", "predict_expectation"``
-    scoring_method: function
-        Provide a way to produce a ``score`` on the scikit-learn model. Signature should look like (durations, predictions, event_observed=None)
-
-    """
-    name = "SkLearn" + fitter.__name__
-    klass = type(
-        name,
-        (_SklearnModel,),
-        {
-            "lifelines_model": fitter,
-            "_event_col": event_col,
-            "_predict_method": predict_method,
-            "_fit_method": "fit",
-            "_scoring_method": staticmethod(scoring_method),
-        },
-    )
-    globals()[klass.__name__] = klass
-    return klass