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

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

@@ -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/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/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/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
         --------
@@ -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/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/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/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.dist-info → lifelines-0.28.0.dist-info}/METADATA

@@ -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,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: pandas >=1.2.0
 Requires-Dist: matplotlib >=3.0
 Requires-Dist: autograd >=1.5
 Requires-Dist: autograd-gamma >=0.3

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

@@ -1,10 +1,10 @@
 lifelines/__init__.py,sha256=F_sKrawq6L4GwTPgOu4FjoGUKQ2gfelAVIQOW1Ee8Ao,2241
 lifelines/calibration.py,sha256=Luii7bkJ2YB0jpuOYYhI22aUyEc1gLsS10Pno6Sqo98,4113
-lifelines/exceptions.py,sha256=Kf6GN2vB-SHde2mbPomj2PhpnCvCBOSTUZLY1jwOw-U,514
+lifelines/exceptions.py,sha256=8T1vQuI6Fnf_5OfiJahksn5Soe-SmU9Y2IA7HYen460,577
 lifelines/generate_datasets.py,sha256=WsvvrZt0jEYQ7-Fp53vrCq7MzmAM2pPUSoCaiQRwN5g,10155
 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=a1Hb9Vpjox_LGg1wAeN82zL0efHoU5UicQ_OpuCT9_E,88
 lifelines/datasets/CuZn-LeftCensoredDataset.csv,sha256=PxTdZcJPPbhtaadpHjhMFVcUxmSn84BuDarujZIJpm4,1996
 lifelines/datasets/__init__.py,sha256=dhFp0uvLVBoAPBNSziknPpNc-ML9Ega6X2yL2UJHQ1M,19976
 lifelines/datasets/anderson.csv,sha256=nTAtTK8mf0ymU88nKvO2Fj0WL9SE9o4S0GVujmX8Cl4,580
@@ -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/__init__.py,sha256=ZqJoIOtP_-esET_V_SEnlHhOWyVw-JKnYgj7CiF10pA,151639
 lifelines/fitters/aalen_additive_fitter.py,sha256=vRQb38weMcknyxC9bJwiALwCzxmJ5DsEZwHkz2zV93k,21518
 lifelines/fitters/aalen_johansen_fitter.py,sha256=w_2MV7Bbtr0swJ0VdySqirhlGsjbYyqduRx9iLKd6XA,14172
-lifelines/fitters/breslow_fleming_harrington_fitter.py,sha256=Te1Y73lIIKhTC6yMADe35RVHI4XOLF17ub-N8oudS4I,4091
+lifelines/fitters/breslow_fleming_harrington_fitter.py,sha256=_86qU3wMHEyuCKLjhHLERP_ymNnlSvi7chWgi8Kygxg,4293
 lifelines/fitters/cox_time_varying_fitter.py,sha256=i8_mmJZm0VjHnX7wZYeLwMgpJryr1hfd69iRwaBn33Q,34656
-lifelines/fitters/coxph_fitter.py,sha256=uv_e6wR0o3gyZcaNOYbeeZhgfaPXQhtcM-nc3-9kxAg,136853
+lifelines/fitters/coxph_fitter.py,sha256=U8k0mEHn0xsZ-akhUHeBhLsOZvKubAsyK6_JDyO5heE,136864
 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=mLfRxHv_Mgyyp_Lw6HiQNitI9gJyTRIFSG2OjvvcFnk,12827
 lifelines/fitters/mixture_cure_fitter.py,sha256=UetFlv9EfFYMDt95M2iR354lna5RKeWtO_lkoaMmoZE,5416
-lifelines/fitters/nelson_aalen_fitter.py,sha256=UNlEX5wR6xsUmEmJ2n2MEqblz-KvGmvlh8eGHfuQf6Y,10666
+lifelines/fitters/nelson_aalen_fitter.py,sha256=QSE6E0ia6-TeHMIoMyo6nTmq8MHM21CgoUOdH7d1QFE,10686
 lifelines/fitters/npmle.py,sha256=HV3yeu1byVv5oBSdv5TuLUg2X5NUxydxj8-h_xYScB0,10143
 lifelines/fitters/piecewise_exponential_fitter.py,sha256=j48sXaEODClFmfFP3THb0qJ3_Q7ctJz19j50Uo1QJME,3357
 lifelines/fitters/piecewise_exponential_regression_fitter.py,sha256=JuGm93cKQBu6KBTHEOoheLJfMqP0h1ckeQjMIpC8aQo,4978
 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=qEAVyYZCAvNInTSp4qvFxGFDhz_aKPp2NcRAqvr_1xA,70428
 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.28.0.dist-info/LICENSE,sha256=AasDeD139SnTdfXbKgN4BMyMgBlRy9YFs60tNrB4wf0,1079
+lifelines-0.28.0.dist-info/METADATA,sha256=6zMJUnOh6TWoVtj87HGTmlPCsIopdr9jOeu_2wKmoP4,3188
+lifelines-0.28.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+lifelines-0.28.0.dist-info/top_level.txt,sha256=3i57Z4mtpc6jWrsW0n-_o9Y7CpzytMTeLMPJBHYAo0o,10
+lifelines-0.28.0.dist-info/RECORD,,

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

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.42.0)
 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