SurvHive: a package to consistently access multiple survival-analysis packages

Cesare Rollo; Flavio Sartori; Giovanni Birolo; Ivan Rossi; Piero Fariselli; Tiziana Sanavia

REVIEW 4 major objections 4 minor 14 references

SurvHive: a package to consistently access multiple survival-analysis packages

T0 review · 4 major / 4 minor · reviewed 2026-08-09 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SurvHive presents a Python package that unifies eight survival-analysis implementations behind a single scikit-learn-compatible interface, enabling consistent training, tuning, and comparison of classical and deep-learning survival models.

desk verdict A useful wrapper package whose core promise—faithful, unbiased access to underlying survival models—is asserted but never demonstrated; worth reviewing after validation is added. read the letter →

arxiv 2502.02223 v1 pith:OFMOK66Y submitted 2025-02-04 q-bio.QM cs.LG

Giovanni Birolo , Ivan Rossi , Flavio Sartori , Cesare Rollo , Tiziana Sanavia , Piero Fariselli This is my paper · ORCID

classification q-bio.QMcs.LG

keywords survivalanalysistime-to-eventpredictionmachinelearningdeepcensoreddatascikit-learnAPImodelcomparisonPythonpackage

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SurvHive is a Python package that wraps eight existing survival-analysis implementations behind a single, consistent API modeled on scikit-learn. The paper's central claim is that this unification lets practitioners train, evaluate, and compare classical statistical models and modern deep-learning survival models without learning each library's data formats, interfaces, and preprocessing quirks. If the claim holds, the package lowers the barrier to entry for applying state-of-the-art survival methods and makes head-to-head comparisons more reliable, because every model is invoked and scored through the same code path. The package also adds time-dependent evaluation metrics and censoring-aware cross-validation defaults that are missing from most of the wrapped libraries.

What carries the argument

The central mechanism is the SurvivalEstimator dataclass, which subclasses scikit-learn's BaseEstimator and follows the Adapter pattern to wrap each underlying model. This dataclass standardizes fit, predict, and score calls, exposes survival-function prediction, and carries a default hyper-parameter grid plus random-seed handling. Around it, the optimization submodule provides censoring-stratified, repeated cross-validation for grid or random search, and the metrics submodule implements Antolini's time-dependent concordance index, Brier scores, and time-quantile AUROC as scikit-learn scorers.

What would settle it

Run one wrapped model, such as DeepHitSingle or FastCPH, and the same model's standalone implementation on an identical dataset with identical hyper-parameters, then compare predicted risk scores and survival functions for numerical agreement.

Watch

Extended reading notes

Core claim

The central discovery is a working software bridge. By subclassing scikit-learn's BaseEstimator and applying the Adapter pattern, SurvHive exposes eight models—Cox proportional hazards, elastic-net Cox, gradient-boosted survival analysis, random survival forest, DeepHit, Deep Survival Machines, FastCPH, and a transformer-based survival model—through a uniform fit/predict/score interface. The authors argue that wrapping rather than re-implementing existing methods reduces the risk of unintended changes to complex algorithms, and therefore reduces bias when the models are compared on equal footing. The interface adds a predict_survival method for survival-function output, default hyper-parameter grids for optimization, and a seeded random-number parameter for reproducibility.

Load-bearing premise

The load-bearing premise is that SurvHive's adapter wrappers faithfully reproduce the behavior of the original packages, since the paper does not test output parity; if an adapter introduces a subtle bug or version mismatch, the comparative evaluations the package enables would be skewed.

Editorial extensions

If this is right

A user can fit, tune, and score eight survival models on one dataset with identical code, making multi-model benchmark comparisons a few lines of work.
The default scoring metric, Antolini's concordance index, is appropriate for deep-learning models whose risk ranking changes over time, which the classic C-index mishandles.
The censoring-stratified repeated cross-validation default gives fairer hyper-parameter selection on censored data than ordinary K-fold splits.
Because each method is wrapped rather than reimplemented, upstream improvements to the underlying packages automatically propagate into SurvHive.
The scikit-learn-compatible scorers let users plug survival metrics into existing machine-learning pipelines and even adapt standard classification metrics like Matthews correlation coefficient.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A direct testable consequence the paper leaves implicit: parity checks between SurvHive adapters and their standalone upstream packages would confirm whether the 'reduced bias' claim is actually met in practice.
The Adapter-based architecture makes SurvHive a natural hub for community benchmarks; adding a new model is a matter of writing one wrapper, so the package could grow into a living comparison of survival methods.
Because all metrics and splits are centralized, SurvHive could serve as a neutral referee in method evaluation, reducing the variance that comes from each author's preferred preprocessing and scoring choices.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Short version: this is a modest but legitimate software contribution, and the paper as written doesn't yet demonstrate it works. The package wraps eight survival models behind a scikit-learn-style API, adds survival-specific scorers (Antolini C-index, time-dependent Brier/AUROC), and extends FastCPH to output survival functions. That integration is new, even if no new model or algorithm appears. The motivation is real: comparing survival models usually means fighting incompatible interfaces, and a unified adapter layer could save people real time.

What the paper does well: the design choices are sensible—subclassing BaseEstimator, using sksurv's structured array format, stratifying CV splits by censoring. The metric scorers take the fitted estimator as an argument, which is a nice touch for time-dependent metrics. The citation list covers the original methods fairly, and the authors are upfront about only supporting single-event data.

The soft spots are real. The central promise is that wrapping avoids re-implementation and therefore reduces bias in comparisons. That promise is never tested. There is no equivalence test showing SurvHive's CoxNet gives the same predictions as scikit-survival's coxnet, or that DeepHitSingle matches PyCox. Without that, the claim of unbiased comparison is just an assertion. Worse, the FastCPH extension is exactly the kind of reimplementation they say they avoid, and it gets no validation either. The stress-test note is correct on both points. The appendix code is garbled—variable names split by spaces, half-written list comprehensions—so the printed example cannot be run, which undercuts the reproducibility story. I'd treat that as a manuscript defect, not necessarily a package defect; the GitHub repo may be fine. But the paper should either paste the real notebook output or omit the appendix.

The conclusion also oversells ('significant advancement'). It's a convenience layer, not a scientific advance. That's fine if stated plainly.

Who is this for? Someone doing survival-model benchmarking who wants one API to call Cox, RSF, DeepHit, DSM, FastCPH, and SurvTRACE. That reader would find the package useful, and the paper gives a decent overview. But I wouldn't trust it until the wrapper equivalence is checked. The package should have unit tests against the underlying libraries, and the paper should report a smoke test on a real dataset.

My recommendation: send it to peer review as a software/tool paper, but with required revisions—add a minimal verification benchmark, fix the appendix, and soften the conclusions. It deserves referee time because the tool is potentially useful and the engineering is sound in principle.

Referee Report

4 major / 4 minor

Summary. The paper introduces SurvHive, a Python package that wraps eight survival-analysis models from scikit-survival, PyCox, auton-survival, LassoNet, and SurvTRACE behind a scikit-learn-style adapter interface. The package adds common facilities: fit/predict/score/predict_survival methods, time-dependent metrics (Antolini C-index, Brier score, time-dependent AUROC), censoring-stratified cross-validation, hyperparameter optimization helpers, and dataset utilities. The manuscript describes the package architecture, the included models, metrics, dataset preparation conventions, installation, and usage examples in an appendix. The central claim is that SurvHive lowers the barrier to using and comparing survival-analysis models while reducing bias in comparative evaluation by avoiding re-implementation. The paper contains no benchmark, no test suite, and no quantitative demonstration that the adapters faithfully reproduce the wrapped packages' behavior; the appendix code examples contain multiple syntax errors and corrupted identifiers.

Significance. If the package worked as described, it would be a plausible convenience layer for practitioners who want to compare classical and deep-learning survival models through one API. The adapter pattern is an appropriate design, and the inclusion of time-dependent metrics is a useful feature. The manuscript is also honest about the package's limited scope (single, non-competing events and minimal data preparation). However, the paper's core value proposition is faithful, unbiased comparison, and that proposition is not tested anywhere: no unit tests, no equivalence checks against the underlying packages, and no empirical demonstration on any dataset. The appendix examples appear not to have been executed end-to-end. Consequently, the contribution is currently a software description with unverified behavior rather than a validated software contribution. The issues are substantial but fixable in a revision: adding smoke tests, adapter-equivalence checks, and a small worked benchmark would directly address the main gap.

major comments (4)

[Section 2 (Application description)] The central claim that the adapter design 'avoids re-implementation' and 'allows for a reduced bias in the comparative evaluation' is not substantiated by any test. The paper provides no unit tests, no equivalence tests, and no benchmark showing that SurvHive's fit, predict, predict_survival, and score produce the same outputs as the original packages on identical inputs. For example, the conversion between the structured array format of scikit-survival and the formats expected by PyCox/auton-survival/LassoNet is a nontrivial step; an error in censoring indicators or event-time mapping would change scores and rankings. The authors should add a systematic equivalence test (or at least a small set of smoke tests) covering each wrapper and each data format conversion, and report the results.
[Section 2.1 (Models provided)] The statement that 'FastCPH has been extended to support the calculation of the Survival function too' contradicts the paper's stated avoidance of re-implementation: this extension is exactly an added piece of code whose correctness is not verified. Since FastCPH is a proportional-hazards model, computing a survival function requires estimating or importing the baseline hazard, and a bug there would affect every metric that uses predict_survival. The manuscript should describe how the survival function is computed and include a validation test comparing FastCPH's risk ordering and survival-function outputs against a closed-form or reference implementation.
[Appendix A.2-A.4 (SurvHive usage examples)] The printed code examples contain multiple syntax errors and corrupted identifiers, which undermines the claim that the documented workflow has been exercised. For instance, 'f o r in vanilla mods . keys ( )' is not valid Python; 'imputer . transform ( )' is missing the data argument; 'y tr ain' appears where 'y tr' was defined; and several function names are split by spaces. These are not stylistic quirks but invalid code. The appendix should be replaced with an executed notebook output or a clearly tested script; otherwise the reader cannot reproduce the advertised workflow from the paper.
[Section 3 (Conclusion) / overall] The paper contains no quantitative evaluation of any kind. It does not demonstrate SurvHive on one of the included benchmark datasets, report runtime, show C-index/Brier/AUROC values, or compare SurvHive's results with the outputs of the underlying packages. For a software paper whose purpose is to enable reliable comparison, such a demonstration is load-bearing, not cosmetic. The authors should add a small experimental section (e.g., on one or two public datasets) showing that the package installs, runs, and produces sensible scores for all eight methods, and ideally a consistency check against the original packages.

minor comments (4)

[Section 1 (Introduction)] The text states that lack of observed events is 'called left-censoring'; the described situation (event not observed by the end of follow-up) is right-censoring. This terminology error appears in the first paragraph and should be corrected.
[Section 2.2 (Metrics)] The paper refers to 'Harrel's Concordance-index' and 'Harrel's C-index'; the standard spelling is 'Harrell's'. Also, the default metric is stated to be Antolini's Concordance Index, but the reader is not told how the Antolini index is computed for models that only output a risk score (as opposed to a survival function); a brief explanation would help.
[Appendix A.2] The reader is asked to upload a CSV with columns 'event' and 'event time', but the code then uses 'get_x_y(dataset, attr_labels=[...], pos_label=True)'. It would be clearer to show a concrete CSV header or a small example DataFrame, since the package's expected input format is central to usability.
[References / Appendix] The final URL in the appendix is truncated as 'https://github.com/compbiomed-unito/survhi'; the full documentation URL should be given. Also, the author name 'Piero F ariselli' contains an internal space and the copyright line says '©2022' while the paper is dated 2025.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: SurvHive is a wrapper package with no derivation chain, no fitted predictions, and no load-bearing self-citations.

full rationale

The paper contains no derivation chain to walk: SurvHive is an adapter/wrapper package, and its claims are about API design and software interoperability, not about predicted quantities derived from inputs. The central claim that the package unifies survival-analysis methods behind a scikit-learn-style interface is a software description and is in principle falsifiable by running the code, not by any reduction of outputs to inputs. There are no fitted parameters called predictions, no uniqueness theorems imported from the authors, and no renaming of a known empirical result. The reference list contains no self-citations (none of the paper's authors appear in the references), so no self-citation chain is load-bearing. The sentence in Section 2 about avoiding re-implementation to reduce bias in comparative evaluation is an assertion about the Adapter design, not a claim that a fitted value equals a prediction; if an adapter mis-converts outputs, that would be an implementation bug, not circularity. The FastCPH extension in Section 2.1 to support survival-function calculation is a reimplementation whose correctness is untested, but it is not presented as a derivation from the package's own inputs. Appendix A contains garbled code (e.g., '! pip i n s t a l l survhive' and '\ l e f t ('), suggesting the documented example was not executed end-to-end; that is a verification and reproducibility concern, not a circularity concern. Because no step reduces, by the paper's own text, to its own input, the circularity score is 0.

Assumptions & free parameters 0 free parameters · 2 assumptions · 0 invented entities

The paper introduces no free parameters, no new mathematical axioms, and no new physical or conceptual entities. The only assumptions are about the reliability of the wrapped packages and the suitability of the scikit-learn API as a universal wrapper.

assumptions (2)

domain assumption The correctness of the wrapped packages (scikit-survival, PyCox, Auton Survival, LassoNet, SurvTRACE) is assumed.
SurvHive is an adapter layer; its behavior depends entirely on the correctness of the underlying implementations, which the paper does not re-verify.
domain assumption The scikit-learn estimator interface is sufficient to represent survival models, including the predict_survival extension.
The design relies on the assumption that all survival models can be exposed via fit, predict, predict_survival, and score without loss of functionality.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SurvHive: a package to consistently access multiple survival-analysis packages." pith.science (2026). https://pith.science/paper/OFMOK66Y

@misc{pith2026250202223,
  author       = {Pith},
  title        = {Pith review of: SurvHive: a package to consistently access multiple survival-analysis packages},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/OFMOK66Y}},
  note         = {Machine review of arXiv:2502.02223}
}

read the original abstract

Survival analysis, a foundational tool for modeling time-to-event data, has seen growing integration with machine learning (ML) approaches to handle the complexities of censored data and time-varying risks. Despite these advances, leveraging state-of-the-art survival models remains a challenge due to the fragmented nature of existing implementations, which lack standardized interfaces and require extensive preprocessing. We introduce SurvHive, a Python-based framework designed to unify survival analysis methods within a coherent and extensible interface modeled on scikit-learn. SurvHive integrates classical statistical models with cutting-edge deep learning approaches, including transformer-based architectures and parametric survival models. Using a consistent API, SurvHive simplifies model training, evaluation, and optimization, significantly reducing the barrier to entry for ML practitioners exploring survival analysis. The package includes enhanced support for hyper-parameter tuning, time-dependent risk evaluation metrics, and cross-validation strategies tailored to censored data. With its extensibility and focus on usability, SurvHive provides a bridge between survival analysis and the broader ML community, facilitating advancements in time-to-event modeling across domains. The SurvHive code and documentation are available freely at https://github.com/compbiomed-unito/survhive.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

14 extracted references · 4 canonical work pages

[1]

event time

or censor ed (valued 0). The latter (“event time”), contains the time of the events, in the same temporal unit. You can upload your dataset as .csv ﬁle into a DataFrame and byimporting the SurvHive library: import pandas as pd import survhive as sv d atas et = pd . r ead cs v ( ’ example dataset . csv ’ , i n d e x c o l=’ id ’ ) After this step we can ge...

work page 2020
[4]

doi: 10.1093/biostatistics/kxj011

ISSN 1468-4357. doi: 10.1093/biostatistics/kxj011. H. Ishwaran, U. B. Kogalur, E. H. Blackstone, and M. S. Lauer. Random survival forests. The Annals of Applied Statistics , 2(3), Sept

doi:10.1093/biostatistics/kxj011
[11]

doi: 10.1145/3535508. 3545521. Wes McKinney. Data Structures for Statistical Computing in Python. In St´ efan van der Walt and Jarrod Millman, editors, Proceedings of the 9th Python in Science Conference , pages 56 – 61,

doi:10.1145/3535508
[13]

e vent”,‘’event time

doi: 10.48550/ ARXIV.2208.09793. 7 SurvHive Appendix A. SurvHive usage examples A.1 Installing Jupyter Notebook and SurvHive When evaluating your data, you have to provide a correct .csv /.xlsx ﬁle. It is necessary to create the correct environment in order to process a .csv/ .xlsx ﬁle or a DataFrame preprocessed. SurvHive can be used in diﬀerent ways: • ...

arXiv doi:10.48550/arxiv.2208.09793
[1950]

doi: 10.1175/1520-0493 (1950)078⟨0001:vofeit⟩ 2.0.co;2

ISSN 0027-0644. doi: 10.1175/1520-0493 (1950)078⟨0001:vofeit⟩ 2.0.co;2. G. Buitinck, M. Louppe, F. Blondel, A. Pedregosa, O. Mueller , V. Grisel, P. Niculae, A. Prettenhofer, J. Gramfort, R. Grobler, J. Layton, A. Vand erplas, B. Joly, Holt, and G. Varoquaux. API design for machine learning software: exp eriences from the scikit- learn project. In ECML PK...

work page doi:10.1175/1520-0493 1950
[1972]

URL http://www.jstor.org/stable/2985181

ISSN 00359246. URL http://www.jstor.org/stable/2985181. E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley,

arXiv
[1997]

doi: 10.1002/( sici) 1097-0258(19970228)16:4⟨385::aid-sim380⟩3.0.co;2-3

ISSN 1097-0258. doi: 10.1002/( sici) 1097-0258(19970228)16:4⟨385::aid-sim380⟩3.0.co;2-3. Z. Wang and J. Sun. Survtrace: transformers for survival analysis with competing events. In Proceedings of the 13th ACM International Conference on Bioinf ormatics, Computational Biology and Health Informatics , BCB

work page doi:10.1002/(
[2005]

doi: 10.1002/sim.2427

ISSN 1097-0258. doi: 10.1002/sim.2427. G. W. Brier. Veriﬁcation of forecasts expressed in terms of p robability. Monthly Weather Review, 78(1):1–3,

doi:10.1002/sim.2427

Show all 14 references

[2008]

doi: 10.1214/08-aoas169

ISSN 1932-6157. doi: 10.1214/08-aoas169. H. Kvamme, O. Borgan, and I. Scheel. Time-to-event predicti on with neural networks and cox regression. Journal of Machine Learning Research , 20(129):1–30,

1932 doi
[2010]

doi: 10.25080/Majora-92bf1922-00a. X. Yang, L. Abraham, S. Kim, P. Smirnov, F. Ruan, B. Haibe-Kai ns, and R. Tibshirani. Fastcph: Eﬃcient survival analysis for neural networks. Au g

doi
[2011]

doi: 10.18637/jss.v039.i05

ISSN 1548-7660. doi: 10.18637/jss.v039.i05. R. Tibshirani. The lasso method for variable selection in th e cox model. Statis- tics in Medicine , 16(4):385–395, Feb

doi
[2018]

doi: 10.1609/aaai.v32i 1.11842

ISSN 2374-3468. doi: 10.1609/aaai.v32i 1.11842. I. Lemhadri, F. Ruan, and R. Tibshirani. Lassonet: Neural ne tworks with fea- ture sparsity. Proceedings of machine learning research , 130:10–18,

doi
[2020]

URL https://doi.org/10.5281/zenodo.3509134. F. Pedregosa, G. Varoquaux, A. Gramfort, V. Michel, B. Thiri on, O. Grisel, M. Blon- del, P. Prettenhofer, R. Weiss, V. Dubourg, J. Vanderplas, A . Passos, D. Cournapeau, M. Brucher, M. Perrot, and E. Duchesnay. Scikit-learn: Mach in...

doi
[2022]

doi: 10.48550/arXiv.2204.07276. T. pandas development team. pandas-dev/pandas: Pandas, Fe b

doi arXiv

Pith tools

Reviewed August 9, 2026 · model on record in the stance chip above.

[1] [1]

event time

or censor ed (valued 0). The latter (“event time”), contains the time of the events, in the same temporal unit. You can upload your dataset as .csv ﬁle into a DataFrame and byimporting the SurvHive library: import pandas as pd import survhive as sv d atas et = pd . r ead cs v ( ’ example dataset . csv ’ , i n d e x c o l=’ id ’ ) After this step we can ge...

work page 2020

[2] [4]

doi: 10.1093/biostatistics/kxj011

ISSN 1468-4357. doi: 10.1093/biostatistics/kxj011. H. Ishwaran, U. B. Kogalur, E. H. Blackstone, and M. S. Lauer. Random survival forests. The Annals of Applied Statistics , 2(3), Sept

doi:10.1093/biostatistics/kxj011

[3] [11]

doi: 10.1145/3535508. 3545521. Wes McKinney. Data Structures for Statistical Computing in Python. In St´ efan van der Walt and Jarrod Millman, editors, Proceedings of the 9th Python in Science Conference , pages 56 – 61,

doi:10.1145/3535508

[4] [13]

e vent”,‘’event time

doi: 10.48550/ ARXIV.2208.09793. 7 SurvHive Appendix A. SurvHive usage examples A.1 Installing Jupyter Notebook and SurvHive When evaluating your data, you have to provide a correct .csv /.xlsx ﬁle. It is necessary to create the correct environment in order to process a .csv/ .xlsx ﬁle or a DataFrame preprocessed. SurvHive can be used in diﬀerent ways: • ...

arXiv doi:10.48550/arxiv.2208.09793

[5] [1950]

doi: 10.1175/1520-0493 (1950)078⟨0001:vofeit⟩ 2.0.co;2

ISSN 0027-0644. doi: 10.1175/1520-0493 (1950)078⟨0001:vofeit⟩ 2.0.co;2. G. Buitinck, M. Louppe, F. Blondel, A. Pedregosa, O. Mueller , V. Grisel, P. Niculae, A. Prettenhofer, J. Gramfort, R. Grobler, J. Layton, A. Vand erplas, B. Joly, Holt, and G. Varoquaux. API design for machine learning software: exp eriences from the scikit- learn project. In ECML PK...

work page doi:10.1175/1520-0493 1950

[6] [1972]

URL http://www.jstor.org/stable/2985181

ISSN 00359246. URL http://www.jstor.org/stable/2985181. E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley,

arXiv

[7] [1997]

doi: 10.1002/( sici) 1097-0258(19970228)16:4⟨385::aid-sim380⟩3.0.co;2-3

ISSN 1097-0258. doi: 10.1002/( sici) 1097-0258(19970228)16:4⟨385::aid-sim380⟩3.0.co;2-3. Z. Wang and J. Sun. Survtrace: transformers for survival analysis with competing events. In Proceedings of the 13th ACM International Conference on Bioinf ormatics, Computational Biology and Health Informatics , BCB

work page doi:10.1002/(

[8] [2005]

doi: 10.1002/sim.2427

ISSN 1097-0258. doi: 10.1002/sim.2427. G. W. Brier. Veriﬁcation of forecasts expressed in terms of p robability. Monthly Weather Review, 78(1):1–3,

doi:10.1002/sim.2427