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

lifelines/metrics.py

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import numpy as np
-from lifelines.utils import concordance_index, ConvergenceError
-
-__all__ = ["concordance_index", "uncensored_l2_log_loss", "uncensored_l1_log_loss"]
-
-
-def uncensored_l1_log_loss(event_times, predicted_event_times, event_observed=None):
-    r"""
-    Calculates the l1 log-loss of predicted event times to true event times for *non-censored*
-    individuals only.
-
-    .. math::  1/N \sum_{i} |log(t_i) - log(q_i)|
-
-    Parameters
-    ----------
-      event_times:
-        a (n,) array of observed survival times.
-      predicted_event_times:
-        a (n,) array of predicted survival times.
-      event_observed:
-        a (n,) array of censored flags, 1 if observed,  0 if not. Default None assumes all observed.
-
-    Returns
-    -------
-      l1-log-loss: a scalar
-    """
-    if event_observed is None:
-        event_observed = np.ones_like(event_times, dtype=bool)
-
-    ix = event_observed.astype(bool)
-    return np.abs(np.log(event_times[ix]) - np.log(predicted_event_times[ix])).mean()
-
-
-def uncensored_l2_log_loss(event_times, predicted_event_times, event_observed=None):
-    r"""
-    Calculates the l2 log-loss of predicted event times to true event times for *non-censored*
-    individuals only.
-
-    .. math::  1/N \sum_{i} (log(t_i) - log(q_i))**2
-
-    Parameters
-    ----------
-      event_times:
-        a (n,) array of observed survival times.
-      predicted_event_times:
-        a (n,) array of predicted survival times.
-      event_observed:
-        a (n,) array of censored flags, 1 if observed,  0 if not. Default None assumes all observed.
-
-    Returns
-    -------
-      l2-log-loss: a scalar
-    """
-    if event_observed is None:
-        event_observed = np.ones_like(event_times, dtype=bool)
-
-    ix = event_observed.astype(bool)
-    return np.power(np.log(event_times[ix]) - np.log(predicted_event_times[ix]), 2).mean()

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