lifelines 0.30.0__tar.gz → 0.30.1__tar.gz

{lifelines-0.30.0/lifelines.egg-info → lifelines-0.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lifelines
-Version: 0.30.0
+Version: 0.30.1
 Summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
 Home-page: https://github.com/CamDavidsonPilon/lifelines
 Author: Cameron Davidson-Pilon
@@ -18,11 +18,22 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.14.0
 Requires-Dist: scipy>=1.7.0
-Requires-Dist: pandas>=2.1
+Requires-Dist: pandas<3.0,>=2.1
 Requires-Dist: matplotlib>=3.0
 Requires-Dist: autograd>=1.5
 Requires-Dist: autograd-gamma>=0.3
 Requires-Dist: formulaic>=0.2.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ![](http://i.imgur.com/EOowdSD.png)
 

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/fitters/__init__.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 from functools import partial, wraps
 from inspect import getfullargspec
-from datetime import datetime
+from datetime import datetime, UTC
 from textwrap import dedent
 import typing as t
 import collections
@@ -1229,11 +1229,15 @@ class ParametricUnivariateFitter(UnivariateFitter):
         # use numerical solver to find the value p = e^{-H(t)}. I think I could use `root` in scipy
         # instead of the scalar version. TODO
         def _find_root(_p):
-            f = lambda t: _p - self.survival_function_at_times(t).values
-            fprime = lambda t: self.survival_function_at_times(t).values * self.hazard_at_times(t).values
+            survival_at_t = lambda t: float(self.survival_function_at_times(t).values[0])
+            hazard_at_t = lambda t: float(self.hazard_at_times(t).values[0])
+            f = lambda t: _p - survival_at_t(t)
+            fprime = lambda t: survival_at_t(t) * hazard_at_t(t)
             return root_scalar(f, bracket=(1e-10, 2 * self.timeline[-1]), fprime=fprime, x0=1.0).root
 
         try:
+            if np.isscalar(p):
+                return float(_find_root(p))
             find_root = np.vectorize(_find_root, otypes=[float])
             return find_root(p)
         except ValueError:
@@ -1776,7 +1780,7 @@ class ParametricRegressionFitter(RegressionFitter):
         fit_options: Optional[dict] = None,
     ) -> ParametricRegressionFitter:
 
-        self._time_fit_was_called = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S") + " UTC"
+        self._time_fit_was_called = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S") + " UTC"
         self._n_examples = df.shape[0]
         self.weights_col = weights_col
         self.entry_col = entry_col

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/fitters/aalen_additive_fitter.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 import warnings
-from datetime import datetime
+from datetime import datetime, UTC
 import time
 
 import numpy as np
@@ -153,7 +153,7 @@ class AalenAdditiveFitter(RegressionFitter):
             aaf.print_summary()
 
         """
-        self._time_fit_was_called = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S") + " UTC"
+        self._time_fit_was_called = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S") + " UTC"
 
         df = df.copy()
 
@@ -244,7 +244,7 @@ class AalenAdditiveFitter(RegressionFitter):
 
             hazards_[i, :] = v
 
-            variance_hazards_[i, :] = (V ** 2).sum(1)
+            variance_hazards_[i, :] = (V**2).sum(1)
 
             X[exits, :] = 0
 
@@ -500,7 +500,7 @@ It's important to know that the naive variance estimates of the coefficients are
             # normally (weights * X).dot(Y) / X.dot(weights * X), but we have a slightly different form here.
             beta = X.dot(Y) / X.dot(weights * X)
             errors = Y.values - np.outer(X, beta)
-            var = (errors ** 2).sum(0) / (Y.shape[0] - 2) / X.dot(weights * X)
+            var = (errors**2).sum(0) / (Y.shape[0] - 2) / X.dot(weights * X)
             return beta, np.sqrt(var)
 
         weights = survival_table_from_events(self.durations, self.event_observed).loc[self._index, "at_risk"].values

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/fitters/aalen_johansen_fitter.py

@@ -5,7 +5,7 @@ import pandas as pd
 import warnings
 
 from lifelines.fitters import NonParametricUnivariateFitter
-from lifelines.utils import _preprocess_inputs, inv_normal_cdf, CensoringType, coalesce
+from lifelines.utils import _preprocess_inputs, inv_normal_cdf, CensoringType, coalesce, LinearAccumulator, QuadraticAccumulator
 from lifelines import KaplanMeierFitter
 from lifelines.plotting import _plot_estimate
 
@@ -219,22 +219,28 @@ class AalenJohansenFitter(NonParametricUnivariateFitter):
             ci_labels = ["%s_upper_%g" % (self._label, ci), "%s_lower_%g" % (self._label, ci)]
         assert len(ci_labels) == 2, "ci_labels should be a length 2 array."
 
-        # Have to loop through each time independently. Don't think there is a faster way
+        # Use prefix sum algorithm to reduce time complexity to O(n), by cumulatively updating terms.
+        first_term_function = QuadraticAccumulator()
+        second_term = 0
+        third_term_function = LinearAccumulator()
         all_vars = []
         for _, r in df.iterrows():
-            sf = df.loc[df.index <= r.name].copy()
             F_t = float(r["Ft"])
-            first_term = np.sum((F_t - sf["Ft"]) ** 2 * sf["observed"] / sf["at_risk"] / (sf["at_risk"] - sf["observed"]))
-            second_term = np.sum(
-                sf["lagS"] ** 2
-                / sf["at_risk"]
-                * sf[self.label_cmprisk]
-                / sf["at_risk"]
-                * (sf["at_risk"] - sf[self.label_cmprisk])
-                / sf["at_risk"]
+
+            first_term_coefficient = r["observed"] / r["at_risk"] / (r["at_risk"] - r["observed"])
+            first_term_function.add_quadratic_term(a = first_term_coefficient, b = F_t)
+    
+            second_term += (
+                (r["lagS"] ** 2)
+                * r[self.label_cmprisk]
+                * (r["at_risk"] - r[self.label_cmprisk])
+                / (r["at_risk"] ** 3)
             )
-            third_term = np.sum((F_t - sf["Ft"]) / sf["at_risk"] * sf["lagS"] * sf[self.label_cmprisk] / sf["at_risk"])
-            variance = first_term + second_term - 2 * third_term
+            
+            third_term_coefficient = r["lagS"] * r[self.label_cmprisk] / (r["at_risk"] ** 2)
+            third_term_function.add_linear_term(a = third_term_coefficient, b = F_t)
+
+            variance = first_term_function.evaluate(F_t) + second_term - 2 * third_term_function.evaluate(F_t)
             all_vars.append(variance)
         df["variance"] = all_vars
 

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/fitters/cox_time_varying_fitter.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-from datetime import datetime
+from datetime import datetime, UTC
 import warnings
 import time
 from typing import Optional
@@ -172,7 +172,7 @@ class CoxTimeVaryingFitter(SemiParametricRegressionFitter, ProportionalHazardMix
         self.stop_col = stop_col
         self.start_col = start_col
         self.formula = formula
-        self._time_fit_was_called = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S") + " UTC"
+        self._time_fit_was_called = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S") + " UTC"
 
         df = df.copy()
 
@@ -801,7 +801,9 @@ 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).astype(float), 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-0.30.0 → lifelines-0.30.1}/lifelines/fitters/coxph_fitter.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 from typing import Callable, Iterator, List, Optional, Tuple, Union, Any, Iterable
 from textwrap import dedent, fill
-from datetime import datetime
+from datetime import datetime, UTC
 import warnings
 import time
 
@@ -1214,7 +1214,7 @@ class SemiParametricPHFitter(ProportionalHazardMixin, SemiParametricRegressionFi
             cph.predict_median(df)
 
         """
-        self._time_fit_was_called = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S") + " UTC"
+        self._time_fit_was_called = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S") + " UTC"
         self.duration_col = duration_col
         self.event_col = event_col
         self.robust = robust
@@ -2693,9 +2693,13 @@ See https://stats.stackexchange.com/q/11109/11867 for more.\n",
         if self.strata:
             df = df.set_index(self.strata)
 
-        df = df.sort_values([self.duration_col, self.event_col])
+        df = df.sort_values([col for col in [self.duration_col, self.event_col] if (col is not None)])
         T = df.pop(self.duration_col).astype(float)
-        E = df.pop(self.event_col).astype(bool)
+        E = (
+            df.pop(self.event_col)
+            if (self.event_col is not None)
+            else pd.Series(np.ones(len(df.index)), index=df.index, name="E")
+        ).astype(bool)
         W = df.pop(self.weights_col) if self.weights_col else pd.Series(np.ones_like(E), index=T.index)
         entries = df.pop(self.entry_col) if self.entry_col else None
 

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/plotting.py

@@ -540,7 +540,10 @@ def add_at_risk_counts(
                     event_table_slice.loc[:tick, ["at_risk", "censored", "observed"]]
                     .agg(
                         {
-                            "at_risk": lambda x: x.tail(1).values,
+                            # `Series.tail(1).values` is a 1D array of length 1. In NumPy>=2.4,
+                            # `int(np.array([1]))` raises `TypeError: only 0-dimensional arrays can be converted to Python scalars`.
+                            # Extract a Python scalar for compatibility.
+                            "at_risk": lambda x: x.tail(1).values.item(),
                             "censored": "sum",
                             "observed": "sum",
                         }
@@ -554,7 +557,7 @@ def add_at_risk_counts(
                     )
                     .fillna(0)
                 )
-                counts.extend([int(c) for c in event_table_slice.loc[rows_to_show]])
+                counts.extend([int(np.asarray(c).item()) for c in event_table_slice.loc[rows_to_show]])
             else:
                 counts.extend([0 for _ in range(n_rows)])
         if n_rows > 1:

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/statistics.py

@@ -114,9 +114,9 @@ class StatisticalResult:
             self._print_specific_style(style, decimals=decimals, **kwargs)
         else:
             try:
-                from IPython.display import display
+                from IPython.display import HTML, display
 
-                display(self)
+                display(HTML(self.to_html(decimals=decimals, **kwargs)))
             except ImportError:
                 self._ascii_print(decimals=decimals, **kwargs)
 
@@ -175,7 +175,6 @@ class StatisticalResult:
     def to_ascii(self, decimals=2, **kwargs):
         extra_kwargs = dict(list(self._kwargs.items()) + list(kwargs.items()))
         meta_data = self._stringify_meta_data(extra_kwargs)
-
         df = self.summary
 
         s = "<lifelines.StatisticalResult: {0}>".format(self.test_name)

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/tests/test_estimation.py

@@ -482,6 +482,7 @@ class TestUnivariateFitters:
             assert not isinstance(fitter.predict(1), Iterable)
             assert isinstance(fitter.predict([1, 2]), Iterable)
 
+    @flaky
     def test_cumulative_density_ci_is_ordered_correctly(self, positive_sample_lifetimes, univariate_fitters):
         T = positive_sample_lifetimes[0]
         for f in univariate_fitters:
@@ -558,6 +559,7 @@ class TestUnivariateFitters:
             fitter.fit(positive_sample_lifetimes[0], ci_labels=expected)
             npt.assert_array_equal(fitter.confidence_interval_.columns, expected)
 
+    @flaky
     def test_ci_is_not_all_nan(self, positive_sample_lifetimes, univariate_fitters):
         for f in univariate_fitters:
             fitter = f()
@@ -2119,6 +2121,25 @@ class TestRegressionFitters:
                 formula = "%s" % subset[-1]
                 fitter.fit(df[subset], duration_col="t", formula=formula)
 
+    def test_categorical_prediction(self):
+        df = pd.DataFrame.from_dict(
+            {
+                "t": [1.0, 5.0, 3.0, 4.0, 6.0, 1.0],
+                "categoryb_": pd.Series(["a", "a", "b", "b", "c", "c"], dtype="category"),
+            }
+        )
+
+        df_to_predict = pd.DataFrame.from_dict(
+            {
+                "categoryb_": pd.Series(["a", "b", "c"], dtype="category"),
+            }
+        )
+
+        for fitter in [CoxPHFitter(), WeibullAFTFitter()]:
+            formula = "categoryb_"
+            fitter.fit(df, duration_col="t", formula=formula)
+            fitter.predict_survival_function(df_to_predict)
+
     @pytest.mark.xfail
     def test_regression_model_has_concordance_index_(self, regression_models, rossi):
 

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/tests/test_npmle.py

@@ -73,6 +73,7 @@ def test_mice_and_optimization_flag():
     npt.assert_allclose(results[0][-1], 0.166667, rtol=1e-4)
 
 
+@pytest.mark.xfail
 def test_mice_scipy():
     df = load_mice()
     results = npmle(df["l"], df["u"], verbose=True, fit_method="scipy")

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/tests/test_plotting.py

@@ -44,6 +44,23 @@ def waltons():
     return load_waltons()[["T", "E"]].iloc[:50]
 
 
+def test_add_at_risk_counts_is_numpy_scalar_compatible():
+    # Regression test for https://github.com/CamDavidsonPilon/lifelines/issues/1671:
+    # `add_at_risk_counts` previously produced 1D NumPy arrays (length 1) for "At risk" counts,
+    # which breaks `int(c)` on NumPy>=2.4 (`TypeError: only 0-dimensional arrays can be converted to Python scalars`).
+    matplotlib = pytest.importorskip("matplotlib")
+    matplotlib.use("Agg", force=True)
+    from matplotlib import pyplot as plt
+
+    kmf = KaplanMeierFitter().fit(
+        np.random.exponential(10, size=(100,)),
+        np.random.binomial(1, 0.8, size=(100,)),
+    )
+    ax = kmf.plot_survival_function()
+    add_at_risk_counts(kmf, ax=ax)
+    plt.close(ax.figure)
+
+
 @pytest.mark.skipif("DISPLAY" not in os.environ, reason="requires display")
 class TestPlotting:
     @pytest.fixture

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/tests/test_statistics.py

@@ -561,3 +561,21 @@ def test_survival_difference_at_fixed_point_in_time_test_interval_censoring():
     wf2 = WeibullFitter().fit_interval_censoring(2 * T, 2 * T)
     result = stats.survival_difference_at_fixed_point_in_time_test(T.mean(), wf1, wf2)
     assert result.p_value < 0.05
+
+
+def test_statistical_result_has_correct_decimal():
+    import re
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    results = stats.logrank_test(
+        durations_A=rossi.loc[rossi["fin"] == 0, "week"],
+        durations_B=rossi.loc[rossi["fin"] == 1, "week"],
+        event_observed_A=rossi.loc[rossi["fin"] == 0, "arrest"],
+        event_observed_B=rossi.loc[rossi["fin"] == 1, "arrest"],
+    )
+
+    output = results.to_ascii(decimals=10, test=1)
+    numbers = re.findall(r"\d+\.\d{10}\b", output)
+    assert len(numbers) >= 3

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/tests/utils/test_utils.py

@@ -1016,3 +1016,43 @@ def test_safe_exp():
     assert grad(safe_exp)(4.0) == np.exp(4.0)
     assert grad(safe_exp)(MAX) == np.exp(MAX)
     assert grad(safe_exp)(MAX + 1) == np.exp(MAX)
+
+class TestAccumulators:
+    EPSILON = 1e-10
+    
+    @staticmethod
+    def _check_equality(a: float, b: float) -> None:
+        assert abs(a - b) < TestAccumulators.EPSILON
+
+    def test_linear_accumulator(self):
+        function = utils.LinearAccumulator()
+        TestAccumulators._check_equality(float(0), function.evaluate(0))
+        TestAccumulators._check_equality(float(0), function.evaluate(1))
+        function.add_linear_term(0, 1)
+        TestAccumulators._check_equality(float(0), function.evaluate(0))
+        TestAccumulators._check_equality(float(0), function.evaluate(1))
+        function.add_linear_term(1, -1)
+        TestAccumulators._check_equality(float(1), function.evaluate(0))
+        TestAccumulators._check_equality(float(2), function.evaluate(1))
+        function.add_linear_term(-1, 2)
+        TestAccumulators._check_equality(float(3), function.evaluate(0))
+        TestAccumulators._check_equality(float(3), function.evaluate(1))
+    
+    def test_quadratic_accumulator(self):
+        function = utils.QuadraticAccumulator()
+        TestAccumulators._check_equality(float(0), function.evaluate(0))
+        TestAccumulators._check_equality(float(0), function.evaluate(1))
+        TestAccumulators._check_equality(float(0), function.evaluate(2))
+        function.add_quadratic_term(0, 1)
+        TestAccumulators._check_equality(float(0), function.evaluate(0))
+        TestAccumulators._check_equality(float(0), function.evaluate(1))
+        TestAccumulators._check_equality(float(0), function.evaluate(2))
+        function.add_quadratic_term(1, 2)
+        TestAccumulators._check_equality(float(4), function.evaluate(0))
+        TestAccumulators._check_equality(float(1), function.evaluate(1))
+        TestAccumulators._check_equality(float(0), function.evaluate(2))
+        function.add_quadratic_term(-1, -1)
+        TestAccumulators._check_equality(float(3), function.evaluate(0))
+        TestAccumulators._check_equality(float(-3), function.evaluate(1))
+        TestAccumulators._check_equality(float(-9), function.evaluate(2))
+

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/utils/__init__.py

@@ -1955,3 +1955,54 @@ class CovariateParameterMappings:
         design_info = formulaic.ModelSpec.from_spec(formulaic.Formula(formula).get_model_matrix(df))
 
         return design_info
+    
+class LinearAccumulator:
+    """
+    This class represents a linear function F(x), which can be updated iteratively.
+    """
+    def __init__(self):
+        """
+        Initializes F(x) as 0.
+        """
+        self.const_term: float = 0.0
+        self.linear_term: float = 0.0
+    
+    def add_linear_term(self, a: float, b: float) -> None:
+        """
+        Adds a * (x - b) to F(x).
+        """
+        self.const_term -= a * b
+        self.linear_term += a
+
+    def evaluate(self, x: float) -> float:
+        """
+        Evaluates F(x) at the given value of x.
+        """
+        return self.const_term + self.linear_term * x
+
+class QuadraticAccumulator:
+    """
+    This class represents a quadratic function F(x), which can be updated iteratively.
+    """
+    def __init__(self):
+        """
+        Initializes F(x) as 0.
+        """
+        self.const_term: float = 0.0
+        self.linear_term: float = 0.0
+        self.quadratic_term: float = 0.0
+    
+    def add_quadratic_term(self, a: float, b: float) -> None:
+        """
+        Adds a * (x - b)^2 to F(x).
+        """
+        # a * (x - b)^2 = a * x^2 + (- 2 * a * b) * x + a * b^2
+        self.const_term += a * (b ** 2)
+        self.linear_term -= 2 * a * b
+        self.quadratic_term += a
+
+    def evaluate(self, x: float) -> float:
+        """
+        Evaluates F(x) at the given value of x.
+        """
+        return self.const_term + self.linear_term * x + self.quadratic_term * (x ** 2)

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines/version.py

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

{lifelines-0.30.0 → lifelines-0.30.1/lifelines.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: lifelines
-Version: 0.30.0
+Version: 0.30.1
 Summary: Survival analysis in Python, including Kaplan Meier, Nelson Aalen and regression
 Home-page: https://github.com/CamDavidsonPilon/lifelines
 Author: Cameron Davidson-Pilon
@@ -18,11 +18,22 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.14.0
 Requires-Dist: scipy>=1.7.0
-Requires-Dist: pandas>=2.1
+Requires-Dist: pandas<3.0,>=2.1
 Requires-Dist: matplotlib>=3.0
 Requires-Dist: autograd>=1.5
 Requires-Dist: autograd-gamma>=0.3
 Requires-Dist: formulaic>=0.2.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ![](http://i.imgur.com/EOowdSD.png)
 

{lifelines-0.30.0 → lifelines-0.30.1}/lifelines.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy>=1.14.0
 scipy>=1.7.0
-pandas>=2.1
+pandas<3.0,>=2.1
 matplotlib>=3.0
 autograd>=1.5
 autograd-gamma>=0.3

{lifelines-0.30.0 → lifelines-0.30.1}/reqs/base-requirements.txt

@@ -1,6 +1,6 @@
 numpy>=1.14.0
 scipy>=1.7.0
-pandas>=2.1
+pandas>=2.1,<3.0
 matplotlib>=3.0
 autograd>=1.5
 autograd-gamma>=0.3