scikit-survival 0.23.1__cp313-cp313-win_amd64.whl

scikit_survival-0.23.1.dist-info/RECORD

@@ -0,0 +1,55 @@
+sksurv/__init__.py,sha256=ylL6ChkAkHWnuIFWG5lky_d_ZNFfukUUt5tU0HVJfgo,3710
+sksurv/base.py,sha256=0HXvIivawJMsby7UxnLUFOKbKvurrJEM0KrMIYmqyBU,3801
+sksurv/column.py,sha256=hojN9vVDw2ka5LRueyc3f1g12AjwuzSIiPqGP5js2Nk,6670
+sksurv/compare.py,sha256=WbJb2NFXMncgkcrNKq3Xgo5YqW_klgkDkKJc219aJiw,4212
+sksurv/exceptions.py,sha256=WopRsYNia5MQTvvVXL3U_nf418t29pplfBz6HFtmt1M,819
+sksurv/functions.py,sha256=x63NGGVQVqtFiEG-wXW569q1U_kKJFwbOb9-8BcfpaM,3780
+sksurv/metrics.py,sha256=rAA_UmN-ddNm52OE3pcixZcfg_XKFig7CeQ2eQw7ArI,38379
+sksurv/nonparametric.py,sha256=aZo5tXkv8a6Fup7NKZzSqW9GEtpCfwk82B2RCWvD0QI,19339
+sksurv/preprocessing.py,sha256=WGrL3ngfskFuMqdMxr7Dkw5Bj8NWij_xZuLRqDdz5Eo,5315
+sksurv/testing.py,sha256=9qoUAeRfp3tb4Zg7oCHkBS0DJXkIuxdflRLoV7NEfek,4403
+sksurv/util.py,sha256=S8GnCvsaOUqjbzFXQylXCUnQSfoy057H8FQ4XidYqgI,12276
+sksurv/bintrees/__init__.py,sha256=z0GwaTPCzww2H2aXF28ubppw0Oc4umNTAlFAKu1VBJc,742
+sksurv/bintrees/_binarytrees.cp313-win_amd64.pyd,sha256=MxoXOQkQdRrPLmM5jRTZk-OWEeQayd2NQT74Zcwd82A,66560
+sksurv/datasets/__init__.py,sha256=ZIU1vPRhO2CYpTf-Lbr64S73JkR1CAP7aVBO_wGHHAY,313
+sksurv/datasets/base.py,sha256=l4xiUUNkYbY-JhpU2En6Kr7AZ29cb-KVUxS6SL-RxAk,15126
+sksurv/datasets/data/GBSG2.arff,sha256=oX_UM7Qy841xBOArXBkUPLzIxNTvdtIJqpxXsqGGw9Q,26904
+sksurv/datasets/data/actg320.arff,sha256=BwIq5q_i_75G2rPFQ6TjO0bsiR8MwA6wPouG-SX7TUo,46615
+sksurv/datasets/data/breast_cancer_GSE7390-metastasis.arff,sha256=1dNSJczfgZOjp4Ya0SKREreyGorzWd-rm1ryihwIAck,265026
+sksurv/datasets/data/flchain.arff,sha256=4LVUyEe-45ozaWPy0VkN-1js_MNsKw1gs2E-JRyjU4o,350945
+sksurv/datasets/data/veteran.arff,sha256=LxZtbmq4I82rcB24JeJTYRtlgwPc3vM2OX5hg-q7xTw,5408
+sksurv/datasets/data/whas500.arff,sha256=dvqRzx-nwgSVJZxNVE2zelnt7l3xgzFtMucB7Wux574,28292
+sksurv/ensemble/__init__.py,sha256=aBjRTFm8UE5sTew292-qcplLUCc6owAfY6osWlj-VSM,193
+sksurv/ensemble/_coxph_loss.cp313-win_amd64.pyd,sha256=ZEE6Cfc4Ubd-psYEVQflNGIaDngL6W2QJCnW7qKfiUE,153600
+sksurv/ensemble/boosting.py,sha256=T2DWIPGMK9S_BX9dIuhnptH3v2P5jfCv_d-wXR0l3zE,63690
+sksurv/ensemble/forest.py,sha256=su6MFuBhD2mMM6SAAq8_ixEv4i7kYm40gcBdNeXmw14,36330
+sksurv/ensemble/survival_loss.py,sha256=v3tSou5t1YY6lBydAZYZ66DLqAirvRhErqW1dZYrTWE,6093
+sksurv/io/__init__.py,sha256=dalzZGTrvekCM8wwsB636rg1dwDkQtDWaBOw7TpHr5U,94
+sksurv/io/arffread.py,sha256=47rFxaZuavV0cbFUrZ_NjSmSByWXqkwZ4MkpFK4jw_w,1897
+sksurv/io/arffwrite.py,sha256=Dkvnr_zz4i23xGPDTwxTAOOggbL1GxtgSi1em6kVp0Q,4609
+sksurv/kernels/__init__.py,sha256=R1if2sVd_0_f6LniIGUR0tipIfzRKpzgGYnvrVZZvHM,78
+sksurv/kernels/_clinical_kernel.cp313-win_amd64.pyd,sha256=cVv6Nb9vPfQqiSfLAFY7XhHjgpmO0beiN77ZmKKUQY4,161280
+sksurv/kernels/clinical.py,sha256=kVAMx95rgrerfvGlmuNgW4hc3HojTruKoNnhuaeLkGw,11046
+sksurv/linear_model/__init__.py,sha256=dO6Mr3wXk6Q-KQEuhpdgMeY3ji8ZVdgC-SeSRnrJdmw,155
+sksurv/linear_model/_coxnet.cp313-win_amd64.pyd,sha256=PTpLr_NU8shli8Kl9--DaYTr-TePEZWhppi3opFNjXQ,92160
+sksurv/linear_model/aft.py,sha256=oWtLF-WCCrdmjJtb9e91SHA-be_IQPTf7Kf9VWoXQB8,7616
+sksurv/linear_model/coxnet.py,sha256=ZJAsJImSoGCL6HJ9uXQdph8sDLAZakcIvMuzRy28F4M,20727
+sksurv/linear_model/coxph.py,sha256=PeYw7I_EHSgV3kriUnEhJg6CIdISkFk9ewlzijHC8Nw,21475
+sksurv/meta/__init__.py,sha256=vw8vn6gR50a8O_7VhUw4aRgbSP2k3erVBgYS7ifwOcI,220
+sksurv/meta/base.py,sha256=AdhIkZi9PvucZ3B2lhhFQpQbwp8EUCDUVOiaev_UsX8,1472
+sksurv/meta/ensemble_selection.py,sha256=NTXzq6xvwL5IwdxyjNVkPOgzU_9lzdsyFKCq0YbdOXo,24673
+sksurv/meta/stacking.py,sha256=md3ZKYYlS23YKbbLjWZqtPRSJYAHfLzN9RlC5RgzYEQ,12629
+sksurv/svm/__init__.py,sha256=CSceYEcBPGKRcJZ4R0u7DzwictGln_weLIsbt2i5xeU,339
+sksurv/svm/_minlip.cp313-win_amd64.pyd,sha256=G4o8dbyW7Az9bPcgGmMh2yQaOOwIl9SaCz9pg501lgc,157696
+sksurv/svm/_prsvm.cp313-win_amd64.pyd,sha256=yJqDmx7ybvPy5Vh0MLLgDuloZJInYtqWY4OI-ESr39w,155136
+sksurv/svm/minlip.py,sha256=Elej96P4s6jMNCbGIbNm4ehWI3ew9o2IyF5tfZuTEqg,22416
+sksurv/svm/naive_survival_svm.py,sha256=D6l8ctlpyUPBhcMlF_6KJq9d_tq1Xmtb9w--n8pGcfM,8209
+sksurv/svm/survival_svm.py,sha256=oGac8mWlDOlZPRoK1MmbcigKUq2bWPw1Uc8vYSsSlwI,44730
+sksurv/tree/__init__.py,sha256=ozb0fhURX-lpiSiHZd0DMnjkqhC0XOC2CTZq0hEZLPw,65
+sksurv/tree/_criterion.cp313-win_amd64.pyd,sha256=l0JJbug1cS8lM46DwH_rGrEz5G5GGnfqVDYP4c3vreQ,176128
+sksurv/tree/tree.py,sha256=PPkqq8jDeAHCd9L283-SLCk7lTBfH-HObTOuOXOvqHs,27248
+scikit_survival-0.23.1.dist-info/COPYING,sha256=Czg9WmPaZE9ijZnDOXbqZIftiaqlnwsyV5kt6sEXHms,35821
+scikit_survival-0.23.1.dist-info/METADATA,sha256=alYA45glhQaH9X_MzelejmubVqXGWVaPiiMPqRa6Yns,49841
+scikit_survival-0.23.1.dist-info/WHEEL,sha256=UJbDlEYuWWwgv9Hu0As4Rgv2Qpdka2YFe6UlEKs4AoE,101
+scikit_survival-0.23.1.dist-info/top_level.txt,sha256=fPkcFA-XQGbwnD_ZXOvaOWmSd34Qezr26Mn99nYPvAg,7
+scikit_survival-0.23.1.dist-info/RECORD,,

scikit_survival-0.23.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

scikit_survival-0.23.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+sksurv

sksurv/__init__.py

@@ -0,0 +1,138 @@
+from importlib.metadata import PackageNotFoundError, version
+import platform
+import sys
+
+from sklearn.pipeline import Pipeline, _final_estimator_has
+from sklearn.utils.metaestimators import available_if
+
+from .util import property_available_if
+
+
+def _get_version(name):
+    try:
+        pkg_version = version(name)
+    except ImportError:
+        pkg_version = None
+    return pkg_version
+
+
+def show_versions():
+    sys_info = {
+        "Platform": platform.platform(),
+        "Python version": f"{platform.python_implementation()} {platform}",
+        "Python interpreter": sys.executable,
+    }
+
+    deps = [
+        "scikit-survival",
+        "scikit-learn",
+        "numpy",
+        "scipy",
+        "pandas",
+        "numexpr",
+        "ecos",
+        "osqp",
+        "joblib",
+        "matplotlib",
+        "pytest",
+        "sphinx",
+        "Cython",
+        "pip",
+        "setuptools",
+    ]
+    minwidth = max(
+        max(map(len, deps)),
+        max(map(len, sys_info.keys())),
+    )
+    fmt = "{0:<%ds}: {1}" % minwidth
+
+    print("SYSTEM")
+    print("------")
+    for name, version_string in sys_info.items():
+        print(fmt.format(name, version_string))
+
+    print("\nDEPENDENCIES")
+    print("------------")
+    for dep in deps:
+        version_string = _get_version(dep)
+        print(fmt.format(dep, version_string))
+
+
+@available_if(_final_estimator_has("predict_cumulative_hazard_function"))
+def predict_cumulative_hazard_function(self, X, **kwargs):
+    """Predict cumulative hazard function.
+
+    The cumulative hazard function for an individual
+    with feature vector :math:`x` is defined as
+
+    .. math::
+
+        H(t \\mid x) = \\exp(x^\\top \\beta) H_0(t) ,
+
+    where :math:`H_0(t)` is the baseline hazard function,
+    estimated by Breslow's estimator.
+
+    Parameters
+    ----------
+    X : array-like, shape = (n_samples, n_features)
+        Data matrix.
+
+    Returns
+    -------
+    cum_hazard : ndarray, shape = (n_samples,)
+        Predicted cumulative hazard functions.
+    """
+    Xt = X
+    for _, _, transform in self._iter(with_final=False):
+        Xt = transform.transform(Xt)
+    return self.steps[-1][-1].predict_cumulative_hazard_function(Xt, **kwargs)
+
+
+@available_if(_final_estimator_has("predict_survival_function"))
+def predict_survival_function(self, X, **kwargs):
+    """Predict survival function.
+
+    The survival function for an individual
+    with feature vector :math:`x` is defined as
+
+    .. math::
+
+        S(t \\mid x) = S_0(t)^{\\exp(x^\\top \\beta)} ,
+
+    where :math:`S_0(t)` is the baseline survival function,
+    estimated by Breslow's estimator.
+
+    Parameters
+    ----------
+    X : array-like, shape = (n_samples, n_features)
+        Data matrix.
+
+    Returns
+    -------
+    survival : ndarray, shape = (n_samples,)
+        Predicted survival functions.
+    """
+    Xt = X
+    for _, _, transform in self._iter(with_final=False):
+        Xt = transform.transform(Xt)
+    return self.steps[-1][-1].predict_survival_function(Xt, **kwargs)
+
+
+@property_available_if(_final_estimator_has("_predict_risk_score"))
+def _predict_risk_score(self):
+    return self.steps[-1][-1]._predict_risk_score
+
+
+def patch_pipeline():
+    Pipeline.predict_survival_function = predict_survival_function
+    Pipeline.predict_cumulative_hazard_function = predict_cumulative_hazard_function
+    Pipeline._predict_risk_score = _predict_risk_score
+
+
+try:
+    __version__ = version("scikit-survival")
+except PackageNotFoundError:  # pragma: no cover
+    # package is not installed
+    __version__ = "unknown"
+
+patch_pipeline()

sksurv/base.py

@@ -0,0 +1,103 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import numpy as np
+
+
+class SurvivalAnalysisMixin:
+    def _predict_function(self, func_name, baseline_model, prediction, return_array):
+        fns = getattr(baseline_model, func_name)(prediction)
+
+        if not return_array:
+            return fns
+
+        times = baseline_model.unique_times_
+        arr = np.empty((prediction.shape[0], times.shape[0]), dtype=float)
+        for i, fn in enumerate(fns):
+            arr[i, :] = fn(times)
+        return arr
+
+    def _predict_survival_function(self, baseline_model, prediction, return_array):
+        """Return survival functions.
+
+        Parameters
+        ----------
+        baseline_model : sksurv.linear_model.coxph.BreslowEstimator
+            Estimator of baseline survival function.
+
+        prediction : array-like, shape=(n_samples,)
+            Predicted risk scores.
+
+        return_array : bool
+            If True, return a float array of the survival function
+            evaluated at the unique event times, otherwise return
+            an array of :class:`sksurv.functions.StepFunction` instances.
+
+        Returns
+        -------
+        survival : ndarray
+        """
+        return self._predict_function("get_survival_function", baseline_model, prediction, return_array)
+
+    def _predict_cumulative_hazard_function(self, baseline_model, prediction, return_array):
+        """Return cumulative hazard functions.
+
+        Parameters
+        ----------
+        baseline_model : sksurv.linear_model.coxph.BreslowEstimator
+            Estimator of baseline cumulative hazard function.
+
+        prediction : array-like, shape=(n_samples,)
+            Predicted risk scores.
+
+        return_array : bool
+            If True, return a float array of the cumulative hazard function
+            evaluated at the unique event times, otherwise return
+            an array of :class:`sksurv.functions.StepFunction` instances.
+
+        Returns
+        -------
+        cum_hazard : ndarray
+        """
+        return self._predict_function("get_cumulative_hazard_function", baseline_model, prediction, return_array)
+
+    def score(self, X, y):
+        """Returns the concordance index of the prediction.
+
+        Parameters
+        ----------
+        X : array-like, shape = (n_samples, n_features)
+            Test samples.
+
+        y : structured array, shape = (n_samples,)
+            A structured array containing the binary event indicator
+            as first field, and time of event or time of censoring as
+            second field.
+
+        Returns
+        -------
+        cindex : float
+            Estimated concordance index.
+        """
+        from .metrics import concordance_index_censored
+
+        name_event, name_time = y.dtype.names
+
+        risk_score = self.predict(X)
+        if not getattr(self, "_predict_risk_score", True):
+            risk_score *= -1  # convert prediction on time scale to risk scale
+
+        result = concordance_index_censored(y[name_event], y[name_time], risk_score)
+        return result[0]
+
+    def _more_tags(self):
+        return {"requires_y": True}

sksurv/bintrees/__init__.py

@@ -0,0 +1,15 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+from ._binarytrees import AATree, AVLTree, RBTree
+
+__all__ = ["RBTree", "AVLTree", "AATree"]

sksurv/column.py

@@ -0,0 +1,201 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import logging
+
+import numpy as np
+import pandas as pd
+from pandas.api.types import CategoricalDtype, is_object_dtype
+
+__all__ = ["categorical_to_numeric", "encode_categorical", "standardize"]
+
+
+def _apply_along_column(array, func1d, **kwargs):
+    if isinstance(array, pd.DataFrame):
+        return array.apply(func1d, **kwargs)
+    return np.apply_along_axis(func1d, 0, array, **kwargs)
+
+
+def standardize_column(series_or_array, with_std=True):
+    d = series_or_array.dtype
+    if issubclass(d.type, np.number):
+        output = series_or_array.astype(float)
+        m = series_or_array.mean()
+        output -= m
+
+        if with_std:
+            s = series_or_array.std(ddof=1)
+            output /= s
+
+        return output
+
+    return series_or_array
+
+
+def standardize(table, with_std=True):
+    """
+    Perform Z-Normalization on each numeric column of the given table.
+
+    If `table` is a pandas.DataFrame, only numeric columns are modified,
+    all other columns remain unchanged. If `table` is a numpy.ndarray,
+    it is only modified if it has numeric dtype, in which case the returned
+    array will have floating point dtype.
+
+    Parameters
+    ----------
+    table : pandas.DataFrame or numpy.ndarray
+        Data to standardize.
+
+    with_std : bool, optional, default: True
+        If ``False`` data is only centered and not converted to unit variance.
+
+    Returns
+    -------
+    normalized : pandas.DataFrame
+        Table with numeric columns normalized.
+        Categorical columns in the input table remain unchanged.
+    """
+    new_frame = _apply_along_column(table, standardize_column, with_std=with_std)
+
+    return new_frame
+
+
+def _encode_categorical_series(series, allow_drop=True):
+    values = _get_dummies_1d(series, allow_drop=allow_drop)
+    if values is None:
+        return
+
+    enc, levels = values
+    if enc is None:
+        return pd.Series(index=series.index, name=series.name, dtype=series.dtype)
+
+    if not allow_drop and enc.shape[1] == 1:
+        return series
+
+    names = []
+    for key in range(1, enc.shape[1]):
+        names.append(f"{series.name}={levels[key]}")
+    series = pd.DataFrame(enc[:, 1:], columns=names, index=series.index)
+
+    return series
+
+
+def encode_categorical(table, columns=None, **kwargs):
+    """
+    Encode categorical columns with `M` categories into `M-1` columns according
+    to the one-hot scheme.
+
+    Parameters
+    ----------
+    table : pandas.DataFrame
+        Table with categorical columns to encode.
+
+    columns : list-like, optional, default: None
+        Column names in the DataFrame to be encoded.
+        If `columns` is None then all the columns with
+        `object` or `category` dtype will be converted.
+
+    allow_drop : boolean, optional, default: True
+        Whether to allow dropping categorical columns that only consist
+        of a single category.
+
+    Returns
+    -------
+    encoded : pandas.DataFrame
+        Table with categorical columns encoded as numeric.
+        Numeric columns in the input table remain unchanged.
+    """
+    if isinstance(table, pd.Series):
+        if not isinstance(table.dtype, CategoricalDtype) and not is_object_dtype(table.dtype):
+            raise TypeError(f"series must be of categorical dtype, but was {table.dtype}")
+        return _encode_categorical_series(table, **kwargs)
+
+    def _is_categorical_or_object(series):
+        return isinstance(series.dtype, CategoricalDtype) or is_object_dtype(series.dtype)
+
+    if columns is None:
+        # for columns containing categories
+        columns_to_encode = {nam for nam, s in table.items() if _is_categorical_or_object(s)}
+    else:
+        columns_to_encode = set(columns)
+
+    items = []
+    for name, series in table.items():
+        if name in columns_to_encode:
+            series = _encode_categorical_series(series, **kwargs)
+            if series is None:
+                continue
+        items.append(series)
+
+    # concat columns of tables
+    new_table = pd.concat(items, axis=1, copy=False)
+    return new_table
+
+
+def _get_dummies_1d(data, allow_drop=True):
+    # Series avoids inconsistent NaN handling
+    cat = pd.Categorical(data)
+    levels = cat.categories
+    number_of_cols = len(levels)
+
+    # if all NaN or only one level
+    if allow_drop and number_of_cols < 2:
+        logging.getLogger(__package__).warning(
+            f"dropped categorical variable {data.name!r}, because it has only {number_of_cols} values"
+        )
+        return
+    if number_of_cols == 0:
+        return None, levels
+
+    dummy_mat = np.eye(number_of_cols).take(cat.codes, axis=0)
+
+    # reset NaN GH4446
+    dummy_mat[cat.codes == -1] = np.nan
+
+    return dummy_mat, levels
+
+
+def categorical_to_numeric(table):
+    """Encode categorical columns to numeric by converting each category to
+    an integer value.
+
+    Parameters
+    ----------
+    table : pandas.DataFrame
+        Table with categorical columns to encode.
+
+    Returns
+    -------
+    encoded : pandas.DataFrame
+        Table with categorical columns encoded as numeric.
+        Numeric columns in the input table remain unchanged.
+    """
+
+    def transform(column):
+        if isinstance(column.dtype, CategoricalDtype):
+            return column.cat.codes
+        if is_object_dtype(column.dtype):
+            try:
+                nc = column.astype(np.int64)
+            except ValueError:
+                classes = column.dropna().unique()
+                classes.sort(kind="mergesort")
+                nc = column.map(dict(zip(classes, range(classes.shape[0]))))
+            return nc
+        if column.dtype == bool:
+            return column.astype(np.int64)
+
+        return column
+
+    if isinstance(table, pd.Series):
+        return pd.Series(transform(table), name=table.name, index=table.index)
+    return table.apply(transform, axis=0, result_type="expand")

sksurv/compare.py

@@ -0,0 +1,123 @@
+from collections import OrderedDict
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+from sklearn.utils.validation import check_array
+
+from .util import check_array_survival
+
+__all__ = ["compare_survival"]
+
+
+def compare_survival(y, group_indicator, return_stats=False):
+    """K-sample log-rank hypothesis test of identical survival functions.
+
+    Compares the pooled hazard rate with each group-specific
+    hazard rate. The alternative hypothesis is that the hazard
+    rate of at least one group differs from the others at some time.
+
+    See [1]_ for more details.
+
+    Parameters
+    ----------
+    y : structured array, shape = (n_samples,)
+        A structured array containing the binary event indicator
+        as first field, and time of event or time of censoring as
+        second field.
+
+    group_indicator : array-like, shape = (n_samples,)
+        Group membership of each sample.
+
+    return_stats : bool, optional, default: False
+        Whether to return a data frame with statistics for each group
+        and the covariance matrix of the test statistic.
+
+    Returns
+    -------
+    chisq : float
+        Test statistic.
+    pvalue : float
+        Two-sided p-value with respect to the null hypothesis
+        that the hazard rates across all groups are equal.
+    stats : pandas.DataFrame
+        Summary statistics for each group:  number of samples,
+        observed number of events, expected number of events,
+        and test statistic.
+        Only provided if `return_stats` is True.
+    covariance : array, shape=(n_groups, n_groups)
+        Covariance matrix of the test statistic.
+        Only provided if `return_stats` is True.
+
+    References
+    ----------
+    .. [1] Fleming, T. R. and Harrington, D. P.
+           A Class of Hypothesis Tests for One and Two Samples of Censored Survival Data.
+           Communications In Statistics 10 (1981): 763-794.
+    """
+
+    event, time = check_array_survival(group_indicator, y)
+    group_indicator = check_array(
+        group_indicator,
+        dtype="O",
+        ensure_2d=False,
+        estimator="compare_survival",
+        input_name="group_indicator",
+    )
+
+    n_samples = time.shape[0]
+    groups, group_counts = np.unique(group_indicator, return_counts=True)
+    n_groups = groups.shape[0]
+    if n_groups == 1:
+        raise ValueError("At least two groups must be specified, but only one was provided.")
+
+    # sort descending
+    o = np.argsort(-time, kind="mergesort")
+    x = group_indicator[o]
+    event = event[o]
+    time = time[o]
+
+    at_risk = np.zeros(n_groups, dtype=int)
+    observed = np.zeros(n_groups, dtype=int)
+    expected = np.zeros(n_groups, dtype=float)
+    covar = np.zeros((n_groups, n_groups), dtype=float)
+
+    covar_indices = np.diag_indices(n_groups)
+
+    k = 0
+    while k < n_samples:
+        ti = time[k]
+        total_events = 0
+        while k < n_samples and ti == time[k]:
+            idx = np.searchsorted(groups, x[k])
+            if event[k]:
+                observed[idx] += 1
+                total_events += 1
+            at_risk[idx] += 1
+            k += 1
+
+        if total_events != 0:
+            total_at_risk = k
+            expected += at_risk * (total_events / total_at_risk)
+            if total_at_risk > 1:
+                multiplier = total_events * (total_at_risk - total_events) / (total_at_risk * (total_at_risk - 1))
+                temp = at_risk * multiplier
+                covar[covar_indices] += temp
+                covar -= np.outer(temp, at_risk) / total_at_risk
+
+    df = n_groups - 1
+    zz = observed[:df] - expected[:df]
+    chisq = np.linalg.solve(covar[:df, :df], zz).dot(zz)
+    pval = stats.chi2.sf(chisq, df)
+
+    if return_stats:
+        table = OrderedDict()
+        table["counts"] = group_counts
+        table["observed"] = observed
+        table["expected"] = expected
+        table["statistic"] = observed - expected
+        table = pd.DataFrame.from_dict(table)
+        table.index = pd.Index(groups, name="group", dtype=groups.dtype)
+        return chisq, pval, table, covar
+
+    return chisq, pval

sksurv/datasets/__init__.py

@@ -0,0 +1,10 @@
+from .base import (
+    get_x_y,  # noqa: F401
+    load_aids,  # noqa: F401
+    load_arff_files_standardized,  # noqa: F401
+    load_breast_cancer,  # noqa: F401
+    load_flchain,  # noqa: F401
+    load_gbsg2,  # noqa: F401
+    load_veterans_lung_cancer,  # noqa: F401
+    load_whas500,  # noqa: F401
+)