lifelines 0.27.8__tar.gz → 0.28.0__tar.gz

{lifelines-0.27.8/lifelines.egg-info → lifelines-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lifelines
-Version: 0.27.8
+Version: 0.28.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,15 +9,20 @@ 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.2.0
+Requires-Dist: matplotlib>=3.0
+Requires-Dist: autograd>=1.5
+Requires-Dist: autograd-gamma>=0.3
+Requires-Dist: formulaic>=0.2.2
 
 ![](http://i.imgur.com/EOowdSD.png)
 

{lifelines-0.27.8 → lifelines-0.28.0}/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-0.27.8 → lifelines-0.28.0}/lifelines/fitters/__init__.py

@@ -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)
@@ -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
@@ -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-0.27.8 → lifelines-0.28.0}/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-0.27.8 → lifelines-0.28.0}/lifelines/fitters/coxph_fitter.py

@@ -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

{lifelines-0.27.8 → lifelines-0.28.0}/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-0.27.8 → lifelines-0.28.0}/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-0.27.8 → lifelines-0.28.0}/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
         --------
@@ -107,7 +111,7 @@ class ProportionalHazardMixin:
 
         for variable in self.params_.index.intersection(columns or self.params_.index):
             minumum_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([])
@@ -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-0.27.8 → lifelines-0.28.0}/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))
@@ -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-0.27.8 → lifelines-0.28.0}/lifelines/tests/test_estimation.py

@@ -34,7 +34,14 @@ from lifelines.utils import (
     qth_survival_time,
 )
 
-from lifelines.exceptions import StatisticalWarning, ApproximationWarning, StatError, ConvergenceWarning, ConvergenceError
+from lifelines.exceptions import (
+    ProportionalHazardAssumptionError,
+    StatisticalWarning,
+    ApproximationWarning,
+    StatError,
+    ConvergenceWarning,
+    ConvergenceError,
+)
 from lifelines.fitters import BaseFitter, ParametricUnivariateFitter, ParametricRegressionFitter, RegressionFitter
 from lifelines.fitters.coxph_fitter import SemiParametricPHFitter
 
@@ -475,6 +482,19 @@ class TestUnivariateFitters:
             assert not isinstance(fitter.predict(1), Iterable)
             assert isinstance(fitter.predict([1, 2]), Iterable)
 
+    def test_cumulative_density_ci_is_ordered_correctly(self, positive_sample_lifetimes, univariate_fitters):
+        T = positive_sample_lifetimes[0]
+        for f in univariate_fitters:
+            fitter = f()
+            fitter.fit(T)
+            if not hasattr(fitter, "confidence_interval_cumulative_density_"):
+                continue
+            lower, upper = f"{fitter.label}_lower_0.95", f"{fitter.label}_upper_0.95"
+            assert np.all(
+                (fitter.confidence_interval_cumulative_density_[upper] - fitter.confidence_interval_cumulative_density_[lower])
+                >= 0
+            )
+
     def test_predict_method_returns_exact_value_if_given_an_observed_time(self):
         T = [1, 2, 3]
         kmf = KaplanMeierFitter()
@@ -574,9 +594,9 @@ class TestUnivariateFitters:
                     assert_frame_equal(with_list, with_array)
                     assert_frame_equal(with_tuple, with_array)
 
-                    with_array = fitter.fit_left_censoring(T, C).survival_function_
-                    with_list = fitter.fit_left_censoring(list(T), list(C)).survival_function_
-                    with_tuple = fitter.fit_left_censoring(tuple(T), tuple(C)).survival_function_
+                    with_array = fitter.fit_left_censoring(T).survival_function_
+                    with_list = fitter.fit_left_censoring(list(T)).survival_function_
+                    with_tuple = fitter.fit_left_censoring(tuple(T)).survival_function_
                     assert_frame_equal(with_list, with_array)
                     assert_frame_equal(with_tuple, with_array)
 
@@ -1607,6 +1627,13 @@ class TestNelsonAalenFitter:
 
         assert_frame_equal(naf_w_weights.cumulative_hazard_, naf_no_weights.cumulative_hazard_)
 
+    def test_variance_calculation_does_not_overflow(self):
+
+        y = np.random.randint(1, 1000, 100000000)
+        naf = NelsonAalenFitter(nelson_aalen_smoothing=False)
+        naf.fit(y, event_observed=None, timeline=range(0, int(y.max())))
+        assert (naf._cumulative_sq >= 0).all()
+
 
 class TestBreslowFlemingHarringtonFitter:
     def test_BHF_fit_when_KMF_throws_an_error(self):
@@ -2893,6 +2920,38 @@ class TestCoxPHFitter_SemiParametric:
 
         assert np.abs(newton(X, T, E, W, entries)[0] - -0.0335) < 0.0001
 
+    def test_baseline_prediction_with_extreme_means(self, rossi):
+        cph = CoxPHFitter()
+        cph.fit(rossi, "week", "arrest")
+
+        rossi_shifted = rossi.copy()
+        rossi_shifted["prio"] += 100
+        cph_shifted = CoxPHFitter()
+        cph_shifted.fit(rossi_shifted, "week", "arrest")
+
+        # make sure summary stats are equal
+        assert_frame_equal(cph_shifted.summary, cph.summary)
+
+        # confirm hazards are equal
+        assert_frame_equal(cph.baseline_hazard_, cph_shifted.baseline_hazard_)
+        assert_frame_equal(cph.baseline_cumulative_hazard_, cph_shifted.baseline_cumulative_hazard_)
+
+    def test_baseline_prediction_with_extreme_scaling(self, rossi):
+        cph = CoxPHFitter()
+        cph.fit(rossi, "week", "arrest")
+
+        rossi_scaled = rossi.copy()
+        rossi_scaled["prio"] *= 100
+        cph_scaled = CoxPHFitter()
+        cph_scaled.fit(rossi_scaled, "week", "arrest")
+
+        # make sure summary stats are equal - note that CI and coefs are unequal since we scaled params.
+        assert_frame_equal(cph_scaled.summary[["z", "p"]], cph.summary[["z", "p"]])
+
+        # confirm hazards are equal
+        assert_frame_equal(cph.baseline_hazard_, cph_scaled.baseline_hazard_)
+        assert_frame_equal(cph.baseline_cumulative_hazard_, cph_scaled.baseline_cumulative_hazard_)
+
 
 class TestCoxPHFitterPeices:
     @pytest.fixture
@@ -3027,7 +3086,7 @@ class TestCoxPHFitter:
     def test_formula_can_accept_numpy_functions(self, cph, rossi):
         cph.fit(rossi, "week", "arrest", formula="fin + log10(prio+1) + np.sqrt(age)")
         assert "fin" in cph.summary.index
-        assert "log10(prio+1)" in cph.summary.index
+        assert "log10(prio + 1)" in cph.summary.index
         assert "np.sqrt(age)" in cph.summary.index
 
     @pytest.mark.xfail
@@ -3119,9 +3178,14 @@ class TestCoxPHFitter:
 
     def test_formulas_handles_categories_at_inference(self, cph):
         # Create a dummy dataset with some one continuous and one categorical features
-        df = pd.DataFrame({
-            'time': [1, 2, 3, 1, 2, 3], 'event': [0, 1, 1, 1, 0, 0],
-            'cov_cont':[0.1, 0.2, 0.3, 0.1, 0.2, 0.3], 'cov_categ': ['A', 'A', 'B', 'B', 'C', 'C']})
+        df = pd.DataFrame(
+            {
+                "time": [1, 2, 3, 1, 2, 3],
+                "event": [0, 1, 1, 1, 0, 0],
+                "cov_cont": [0.1, 0.2, 0.3, 0.1, 0.2, 0.3],
+                "cov_categ": ["A", "A", "B", "B", "C", "C"],
+            }
+        )
         cph.fit(df, "time", "event", formula="cov_cont + C(cov_categ)")
         cph.predict_survival_function(df.iloc[:4])
 
@@ -3402,6 +3466,11 @@ class TestCoxPHFitter:
         cph.fit(rossi, "week", "arrest")
         cph.check_assumptions(rossi)
 
+    def test_check_assumptions_thows_if_raise_on_fail_enalbed(self, cph, rossi):
+        cph.fit(rossi, "week", "arrest")
+        with pytest.raises(ProportionalHazardAssumptionError):
+            cph.check_assumptions(rossi, p_value_threshold=0.05, raise_on_fail=True)
+
     def test_check_assumptions_for_subset_of_columns(self, cph, rossi):
         cph.fit(rossi, "week", "arrest")
         cph.check_assumptions(rossi, columns=["age"])
@@ -5688,6 +5757,4 @@ class TestMixtureCureFitter:
         T, E = load_kidney_transplant()["time"], load_kidney_transplant()["death"]
         wmc.fit(T, E)
         mcfitter.fit(T, E)
-        print(wmc.summary)
-        print(mcfitter.summary)
         assert_frame_equal(wmc.summary.reset_index(drop=True), mcfitter.summary.reset_index(drop=True), rtol=0.25)

{lifelines-0.27.8 → lifelines-0.28.0}/lifelines/tests/utils/test_utils.py

@@ -15,7 +15,6 @@ from lifelines import CoxPHFitter, WeibullAFTFitter, KaplanMeierFitter, Exponent
 from lifelines.datasets import load_regression_dataset, load_larynx, load_waltons, load_rossi
 from lifelines import utils
 from lifelines import exceptions
-from lifelines.utils.sklearn_adapter import sklearn_adapter
 from lifelines.utils.safe_exp import safe_exp
 
 
@@ -303,6 +302,13 @@ def test_survival_table_from_events_binned_with_empty_bin():
     assert not pd.isnull(event_table).any().any()
 
 
+def test_survival_table_from_events_with_future_bins():
+    df = load_waltons()
+    event_table = utils.survival_table_from_events(df["T"], df["E"], collapse=True, intervals=np.arange(10, 100).tolist())
+    assert not pd.isnull(event_table).any().any()
+    assert event_table.iloc[-1].sum() == 0
+
+
 def test_survival_table_from_events_at_risk_column():
     df = load_waltons()
     # from R
@@ -885,122 +891,6 @@ class TestStepSizer:
         assert ss.next() < start
 
 
-class TestSklearnAdapter:
-    @pytest.fixture
-    def X(self):
-        return load_regression_dataset().drop("T", axis=1)
-
-    @pytest.fixture
-    def Y(self):
-        return load_regression_dataset().pop("T")
-
-    def test_model_has_correct_api(self, X, Y):
-        base_model = sklearn_adapter(CoxPHFitter, event_col="E")
-        cph = base_model()
-        assert hasattr(cph, "fit")
-        cph.fit(X, Y)
-        assert hasattr(cph, "predict")
-        cph.predict(X)
-        assert hasattr(cph, "score")
-        cph.score(X, Y)
-
-    def test_sklearn_cross_val_score_accept_model(self, X, Y):
-        from sklearn.model_selection import cross_val_score
-        from sklearn.model_selection import GridSearchCV
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E")
-        wf = base_model(penalizer=1.0)
-        assert len(cross_val_score(wf, X, Y, cv=3)) == 3
-
-    def test_sklearn_GridSearchCV_accept_model(self, X, Y):
-        from sklearn.model_selection import cross_val_score
-        from sklearn.model_selection import GridSearchCV
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E")
-
-        grid_params = {"penalizer": 10.0 ** np.arange(-2, 3), "model_ancillary": [True, False]}
-        clf = GridSearchCV(base_model(), grid_params, cv=4)
-        clf.fit(X, Y)
-
-        assert clf.best_params_ == {"model_ancillary": True, "penalizer": 100.0}
-        assert clf.predict(X).shape[0] == X.shape[0]
-
-    def test_model_can_accept_things_like_strata(self, X, Y):
-        X["strata"] = np.random.randint(0, 2, size=X.shape[0])
-        base_model = sklearn_adapter(CoxPHFitter, event_col="E")
-        cph = base_model(strata="strata")
-        cph.fit(X, Y)
-
-    def test_we_can_user_other_prediction_methods(self, X, Y):
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E", predict_method="predict_median")
-        wf = base_model(strata="strata")
-        wf.fit(X, Y)
-        assert wf.predict(X).shape[0] == X.shape[0]
-
-    def test_dill(self, X, Y):
-        import dill
-
-        base_model = sklearn_adapter(CoxPHFitter, event_col="E")
-        cph = base_model()
-        cph.fit(X, Y)
-
-        s = dill.dumps(cph)
-        s = dill.loads(s)
-        assert cph.predict(X).shape[0] == X.shape[0]
-
-    def test_pickle(self, X, Y):
-        import pickle
-
-        base_model = sklearn_adapter(CoxPHFitter, event_col="E")
-        cph = base_model()
-        cph.fit(X, Y)
-
-        s = pickle.dumps(cph, protocol=-1)
-        s = pickle.loads(s)
-        assert cph.predict(X).shape[0] == X.shape[0]
-
-    def test_isinstance(self):
-        from sklearn.base import BaseEstimator, RegressorMixin, MetaEstimatorMixin, MultiOutputMixin
-
-        base_model = sklearn_adapter(CoxPHFitter, event_col="E")
-        assert isinstance(base_model(), BaseEstimator)
-        assert isinstance(base_model(), RegressorMixin)
-        assert isinstance(base_model(), MetaEstimatorMixin)
-
-    @pytest.mark.xfail
-    def test_sklearn_GridSearchCV_accept_model_with_parallelization(self, X, Y):
-        from sklearn.model_selection import cross_val_score
-        from sklearn.model_selection import GridSearchCV
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E")
-
-        grid_params = {"penalizer": 10.0 ** np.arange(-2, 3), "l1_ratio": [0.05, 0.5, 0.95], "model_ancillary": [True, False]}
-        # note the n_jobs
-        clf = GridSearchCV(base_model(), grid_params, cv=4, n_jobs=-1)
-        clf.fit(X, Y)
-
-        assert clf.best_params_ == {"l1_ratio": 0.5, "model_ancillary": False, "penalizer": 0.01}
-        assert clf.predict(X).shape[0] == X.shape[0]
-
-    def test_joblib(self, X, Y):
-        from joblib import dump, load
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E")
-
-        clf = base_model()
-        clf.fit(X, Y)
-        dump(clf, "filename.joblib")
-        clf = load("filename.joblib")
-
-    @pytest.mark.xfail
-    def test_sklearn_check(self):
-        from sklearn.utils.estimator_checks import check_estimator
-
-        base_model = sklearn_adapter(WeibullAFTFitter, event_col="E")
-        check_estimator(base_model())
-
-
 def test_rmst_works_at_kaplan_meier_edge_case():
 
     T = [1, 2, 3, 4, 10]
@@ -1025,7 +915,14 @@ def test_rmst_works_at_kaplan_meier_with_left_censoring():
     assert abs(results[1] - 0) < 0.0001
 
 
-def test_rmst_exactely_with_known_solution():
+def test_rmst_works_with_return_variance():
+    # issue 1578
+    T = [1, 2, 3, 4, 10]
+    kmf = KaplanMeierFitter().fit(T)
+    result = utils.restricted_mean_survival_time(kmf.survival_function_, t=10, return_variance=True)
+
+
+def test_rmst_exactly_with_known_solution():
     T = np.random.exponential(2, 100)
     exp = ExponentialFitter().fit(T)
     lambda_ = exp.lambda_

{lifelines-0.27.8 → lifelines-0.28.0}/lifelines/utils/__init__.py

@@ -311,7 +311,7 @@ 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)
     elif isinstance(model_or_survival_function, lifelines.fitters.UnivariateFitter):
@@ -561,7 +561,7 @@ def _group_event_table_by_intervals(event_table, intervals) -> pd.DataFrame:
     )
     # 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"):
@@ -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)

{lifelines-0.27.8 → lifelines-0.28.0}/lifelines/version.py

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

{lifelines-0.27.8 → lifelines-0.28.0/lifelines.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lifelines
-Version: 0.27.8
+Version: 0.28.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,15 +9,20 @@ 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.2.0
+Requires-Dist: matplotlib>=3.0
+Requires-Dist: autograd>=1.5
+Requires-Dist: autograd-gamma>=0.3
+Requires-Dist: formulaic>=0.2.2
 
 ![](http://i.imgur.com/EOowdSD.png)
 

{lifelines-0.27.8 → lifelines-0.28.0}/lifelines.egg-info/SOURCES.txt

@@ -83,8 +83,6 @@ lifelines/utils/concordance.py
 lifelines/utils/lowess.py
 lifelines/utils/printer.py
 lifelines/utils/safe_exp.py
-lifelines/utils/sklearn_adapter.py
 reqs/base-requirements.txt
 reqs/dev-requirements.txt
-reqs/docs-requirements.txt
-reqs/travis-requirements.txt
+reqs/docs-requirements.txt

{lifelines-0.27.8 → lifelines-0.28.0}/lifelines.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy<2.0,>=1.14.0
 scipy>=1.2.0
-pandas>=1.0.0
+pandas>=1.2.0
 matplotlib>=3.0
 autograd>=1.5
 autograd-gamma>=0.3

{lifelines-0.27.8 → lifelines-0.28.0}/reqs/base-requirements.txt

@@ -1,6 +1,6 @@
 numpy>=1.14.0,<2.0
 scipy>=1.2.0
-pandas>=1.0.0
+pandas>=1.2.0
 matplotlib>=3.0
 autograd>=1.5
 autograd-gamma>=0.3

lifelines-0.28.0/reqs/docs-requirements.txt

@@ -0,0 +1,7 @@
+-r dev-requirements.txt
+sphinx==7.2.6
+sphinx_rtd_theme==2.0.0
+nbsphinx==0.9.3
+jupyter_client==8.6.0
+nbconvert>=6.5.1
+ipykernel==6.28.0

{lifelines-0.27.8 → lifelines-0.28.0}/setup.py

@@ -17,8 +17,6 @@ CLASSIFIERS = [
     "Development Status :: 4 - Beta",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -28,7 +26,7 @@ LICENSE = "MIT"
 PACKAGE_DATA = {"lifelines": ["datasets/*"]}
 DESCRIPTION = "Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression"
 URL = "https://github.com/CamDavidsonPilon/lifelines"
-PYTHON_REQ = ">=3.7"
+PYTHON_REQ = ">=3.9"
 
 setup(
     name=NAME,

lifelines-0.27.8/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

lifelines-0.27.8/reqs/docs-requirements.txt

@@ -1,7 +0,0 @@
--r dev-requirements.txt
-sphinx
-sphinx_rtd_theme
-nbsphinx
-jupyter_client
-nbconvert>=6.5.1
-ipykernel

lifelines-0.27.8/reqs/travis-requirements.txt

@@ -1,5 +0,0 @@
-python-coveralls
-seaborn
-pytest-travis-fold
-dill
--r dev-requirements.txt