Upload 260 files

.gitattributes

@@ -33,3 +33,25 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/coxph_plot_covarite_groups.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lcd_parametric.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_all_regimes.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_kmf_curve.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_kmf_fitter.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_multi_kmf_fitter_2.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_naf_fitter_multi.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_naf_smooth_multi_2.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lifelines_intro_naf_smooth_multi.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lls_democracy.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/lls_regime_type.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/plot_covariate_example3.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/show_censors_plot.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/survival_analysis_intro_censoring.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/survival_calibration_probablilty.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/survival_weibull.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/waltons_cumulative_hazard.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/waltons_survival_function.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/weibull_aft_two_models_side_by_side.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/weibull_aft_two_models.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/weibull_extrapolation.png filter=lfs diff=lfs merge=lfs -text
+lifelines/source/docs/images/weibull_parameters.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "lifelines/mcp_output/start_mcp.py"]

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "lifelines", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Lifelines MCP Service",
+    description="Auto-generated MCP service for lifelines",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Lifelines MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "lifelines MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

lifelines/mcp_output/README_MCP.md

@@ -0,0 +1,124 @@
+# lifelines MCP (Model Context Protocol) Service README
+
+## 1) Project Introduction
+
+This MCP (Model Context Protocol) service wraps the `lifelines` Python library to provide survival analysis capabilities to LLM applications and developer tools.
+
+Core capabilities:
+- Fit survival models (Kaplan–Meier, Cox PH, AFT, Weibull, etc.)
+- Run statistical tests (log-rank, proportional hazards checks, RMST comparisons)
+- Load built-in example datasets
+- Generate calibration and plotting-ready outputs
+- Compute utility metrics (e.g., concordance index)
+
+This service is best suited for data science assistants, clinical analytics workflows, and automated model comparison pipelines.
+
+---
+
+## 2) Installation Method
+
+### Requirements
+- Python 3.9+ recommended
+- System packages for scientific Python stack (if needed)
+- Main dependencies:
+  - `numpy`
+  - `scipy`
+  - `pandas`
+  - `matplotlib`
+  - `autograd`
+  - `autograd-gamma`
+  - `formulaic`
+
+### Install
+pip install lifelines numpy scipy pandas matplotlib autograd autograd-gamma formulaic
+
+### Optional (development/docs/testing)
+pip install pytest sphinx jupyter nbconvert
+
+---
+
+## 3) Quick Start
+
+### Basic workflow
+1. Load or receive a tabular dataset with duration/event columns.
+2. Call a fitter endpoint (for example, Cox or Kaplan–Meier).
+3. Inspect returned coefficients/survival curves/test statistics.
+4. Optionally run diagnostics (PH assumption tests, calibration).
+
+### Example service usage flow
+- `dataset.load` → `model.fit_coxph` → `statistics.logrank_test` → `utils.concordance_index`
+
+### Minimal Python-side equivalent
+from lifelines import CoxPHFitter
+from lifelines.datasets import load_rossi
+
+df = load_rossi()
+cph = CoxPHFitter()
+cph.fit(df, duration_col="week", event_col="arrest")
+print(cph.summary)
+
+---
+
+## 4) Available Tools and Endpoints List
+
+Recommended MCP (Model Context Protocol) service endpoint groups:
+
+### `dataset.*`
+- `dataset.list` — list bundled lifelines datasets
+- `dataset.load` — load a named dataset (e.g., `rossi`, `lung`, `gbsg2`)
+
+### `model.fit_*`
+- `model.fit_kaplan_meier` — non-parametric survival estimation
+- `model.fit_coxph` — Cox proportional hazards regression
+- `model.fit_cox_time_varying` — Cox model with time-varying covariates
+- `model.fit_weibull` / `model.fit_exponential` / `model.fit_lognormal` / `model.fit_loglogistic`
+- `model.fit_aft_*` — AFT regression family (Weibull/LogNormal/LogLogistic)
+- `model.fit_aalen_additive` — additive hazards model
+
+### `statistics.*`
+- `statistics.logrank_test` — two-group survival comparison
+- `statistics.pairwise_logrank_test` — pairwise group comparisons
+- `statistics.multivariate_logrank_test` — multi-group comparison
+- `statistics.proportional_hazard_test` — PH assumption diagnostics
+- `statistics.rmst_difference_test` — restricted mean survival time difference
+
+### `calibration.*`
+- `calibration.survival_probability` — calibration at fixed time horizon
+
+### `metrics.*`
+- `metrics.concordance_index` — ranking/discrimination quality
+
+### `utils.*`
+- `utils.k_fold_cross_validation` — model validation
+- `utils.to_long_format` / `utils.add_covariate_to_timeline` — time-varying data prep
+- `utils.find_best_parametric_model` — parametric model selection helper
+
+### `plot.*` (optional)
+- `plot.survival_curve`
+- `plot.loglogs`
+- `plot.qq`
+- `plot.rmst`
+- `plot.at_risk_counts`
+
+---
+
+## 5) Common Issues and Notes
+
+- **Column mapping errors**: Ensure `duration_col` and `event_col` are explicitly provided.
+- **Convergence warnings**: Common in Cox/AFT models with collinearity or separability; standardize features, reduce covariates, or regularize.
+- **Time-varying format**: Use long/episodic format (`start`, `stop`, `event`) for time-varying models.
+- **Censoring assumptions**: Confirm right/left/interval censoring assumptions match chosen model.
+- **Performance**: Large datasets and heavy diagnostics can be slow; prefer batched requests and limit plotting in production.
+- **Headless environments**: For plotting endpoints on servers, configure non-interactive matplotlib backend.
+- **Dependency consistency**: Pin versions in production for `numpy/scipy/pandas/lifelines`.
+
+---
+
+## 6) Reference Links or Documentation
+
+- Repository: https://github.com/CamDavidsonPilon/lifelines
+- Official docs: https://lifelines.readthedocs.io/
+- Examples: `examples/` directory in the repository
+- Changelog: `CHANGELOG.md` in the repository
+
+If you want, I can also generate a ready-to-use `service.json` tool schema for these MCP (Model Context Protocol) endpoints.

lifelines/mcp_output/analysis.json

@@ -0,0 +1,1585 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/CamDavidsonPilon/lifelines",
+    "summary": "Imported via zip fallback, file count: 86",
+    "file_tree": {
+      ".github/CODE_OF_CONDUCT.md": {
+        "size": 2977
+      },
+      ".github/CONTRIBUTING.md": {
+        "size": 2744
+      },
+      ".github/FUNDING.yml": {
+        "size": 25
+      },
+      ".github/workflows/ci.yaml": {
+        "size": 838
+      },
+      ".github/workflows/pythonpublish.yml": {
+        "size": 862
+      },
+      ".pre-commit-config.yaml": {
+        "size": 412
+      },
+      ".prospector.yaml": {
+        "size": 719
+      },
+      ".readthedocs.yaml": {
+        "size": 1035
+      },
+      "CHANGELOG.md": {
+        "size": 69853
+      },
+      "README.md": {
+        "size": 2257
+      },
+      "conftest.py": {
+        "size": 536
+      },
+      "docs/conf.py": {
+        "size": 9430
+      },
+      "docs/conftest.py": {
+        "size": 749
+      },
+      "docs/docs_requirements.txt": {
+        "size": 32
+      },
+      "docs/images/dist_script.py": {
+        "size": 753
+      },
+      "examples/README.md": {
+        "size": 2547
+      },
+      "examples/aalen_and_cook_simulation.py": {
+        "size": 762
+      },
+      "examples/copula_frailty_weibull_model.py": {
+        "size": 1705
+      },
+      "examples/cox_spline_custom_knots.py": {
+        "size": 406
+      },
+      "examples/crowther_royston_clements_splines.py": {
+        "size": 3662
+      },
+      "examples/cure_model.py": {
+        "size": 1126
+      },
+      "examples/haft_model.py": {
+        "size": 1970
+      },
+      "examples/left_censoring_experiments.py": {
+        "size": 1409
+      },
+      "examples/mixture_cure_model.py": {
+        "size": 1580
+      },
+      "examples/royston_parmar_splines.py": {
+        "size": 4818
+      },
+      "lifelines/__init__.py": {
+        "size": 2241
+      },
+      "lifelines/calibration.py": {
+        "size": 4107
+      },
+      "lifelines/datasets/__init__.py": {
+        "size": 19962
+      },
+      "lifelines/datasets/dfcv_dataset.py": {
+        "size": 2700
+      },
+      "lifelines/exceptions.py": {
+        "size": 577
+      },
+      "lifelines/fitters/__init__.py": {
+        "size": 151829
+      },
+      "lifelines/fitters/aalen_additive_fitter.py": {
+        "size": 21527
+      },
+      "lifelines/fitters/aalen_johansen_fitter.py": {
+        "size": 14424
+      },
+      "lifelines/fitters/breslow_fleming_harrington_fitter.py": {
+        "size": 4293
+      },
+      "lifelines/fitters/cox_time_varying_fitter.py": {
+        "size": 34690
+      },
+      "lifelines/fitters/coxph_fitter.py": {
+        "size": 137349
+      },
+      "lifelines/fitters/crc_spline_fitter.py": {
+        "size": 3126
+      },
+      "lifelines/fitters/exponential_fitter.py": {
+        "size": 2857
+      },
+      "lifelines/fitters/generalized_gamma_fitter.py": {
+        "size": 6482
+      },
+      "lifelines/fitters/generalized_gamma_regression_fitter.py": {
+        "size": 7955
+      },
+      "lifelines/fitters/kaplan_meier_fitter.py": {
+        "size": 24209
+      },
+      "lifelines/fitters/log_logistic_aft_fitter.py": {
+        "size": 7074
+      },
+      "lifelines/fitters/log_logistic_fitter.py": {
+        "size": 4004
+      },
+      "lifelines/fitters/log_normal_aft_fitter.py": {
+        "size": 7890
+      },
+      "lifelines/fitters/log_normal_fitter.py": {
+        "size": 3557
+      },
+      "lifelines/fitters/mixins.py": {
+        "size": 12827
+      },
+      "lifelines/fitters/mixture_cure_fitter.py": {
+        "size": 5416
+      },
+      "lifelines/fitters/nelson_aalen_fitter.py": {
+        "size": 10687
+      },
+      "lifelines/fitters/npmle.py": {
+        "size": 10157
+      },
+      "lifelines/fitters/piecewise_exponential_fitter.py": {
+        "size": 3357
+      },
+      "lifelines/fitters/piecewise_exponential_regression_fitter.py": {
+        "size": 4983
+      },
+      "lifelines/fitters/spline_fitter.py": {
+        "size": 4212
+      },
+      "lifelines/fitters/weibull_aft_fitter.py": {
+        "size": 7772
+      },
+      "lifelines/fitters/weibull_fitter.py": {
+        "size": 3771
+      },
+      "lifelines/generate_datasets.py": {
+        "size": 10188
+      },
+      "lifelines/plotting.py": {
+        "size": 35395
+      },
+      "lifelines/statistics.py": {
+        "size": 35225
+      },
+      "lifelines/tests/__init__.py": {
+        "size": 0
+      },
+      "lifelines/tests/test_estimation.py": {
+        "size": 240527
+      },
+      "lifelines/tests/test_generate_datasets.py": {
+        "size": 1033
+      },
+      "lifelines/tests/test_npmle.py": {
+        "size": 3913
+      },
+      "lifelines/tests/test_plotting.py": {
+        "size": 39463
+      },
+      "lifelines/tests/test_statistics.py": {
+        "size": 20418
+      },
+      "lifelines/tests/utils/test_btree.py": {
+        "size": 880
+      },
+      "lifelines/tests/utils/test_concordance.py": {
+        "size": 2666
+      },
+      "lifelines/tests/utils/test_utils.py": {
+        "size": 40823
+      },
+      "lifelines/utils/__init__.py": {
+        "size": 72185
+      },
+      "lifelines/utils/btree.py": {
+        "size": 4369
+      },
+      "lifelines/utils/concordance.py": {
+        "size": 12245
+      },
+      "lifelines/utils/lowess.py": {
+        "size": 2541
+      },
+      "lifelines/utils/printer.py": {
+        "size": 5861
+      },
+      "lifelines/utils/safe_exp.py": {
+        "size": 4350
+      },
+      "lifelines/version.py": {
+        "size": 88
+      },
+      "mypy.ini": {
+        "size": 567
+      },
+      "paper/paper.md": {
+        "size": 7288
+      },
+      "perf_tests/aaf_perf_test.py": {
+        "size": 571
+      },
+      "perf_tests/batch_vs_single.py": {
+        "size": 2716
+      },
+      "perf_tests/cp_perf_test.py": {
+        "size": 674
+      },
+      "perf_tests/ctv_perf_test.py": {
+        "size": 618
+      },
+      "perf_tests/lognormal_perf_test.py": {
+        "size": 572
+      },
+      "perf_tests/weibull_aft_perf.py": {
+        "size": 720
+      },
+      "perf_tests/weibull_perf_test.py": {
+        "size": 769
+      },
+      "reqs/base-requirements.txt": {
+        "size": 111
+      },
+      "reqs/dev-requirements.txt": {
+        "size": 479
+      },
+      "reqs/docs-requirements.txt": {
+        "size": 135
+      },
+      "setup.py": {
+        "size": 1593
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.lifelines",
+      "source.lifelines.datasets",
+      "source.lifelines.fitters",
+      "source.lifelines.tests",
+      "source.lifelines.utils"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": false,
+    "setup_cfg": false,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "conftest",
+        "module": "conftest",
+        "functions": [
+          "block",
+          "pytest_addoption",
+          "pytest_runtest_setup"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "pytest_runtest_setup": [
+            "item"
+          ],
+          "pytest_addoption": [
+            "parser"
+          ],
+          "block": [
+            "request"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "docs",
+        "module": "conftest",
+        "functions": [
+          "tempdir"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "tempdir": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "docs",
+        "module": "conf",
+        "functions": [
+          "setup"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "setup": [
+            "app"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "crowther_royston_clements_splines",
+        "functions": [
+          "generate_data"
+        ],
+        "classes": [
+          "CRCSplineFitter"
+        ],
+        "function_signatures": {
+          "generate_data": [
+            "n"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "royston_parmar_splines",
+        "functions": [],
+        "classes": [
+          "PHSplineFitter",
+          "POSplineFitter",
+          "SplineFitter",
+          "WeibullFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "cure_model",
+        "functions": [],
+        "classes": [
+          "CureModel"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "haft_model",
+        "functions": [],
+        "classes": [
+          "HAFT"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "copula_frailty_weibull_model",
+        "functions": [],
+        "classes": [
+          "CopulaFrailtyWeilbullModel"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "examples",
+        "module": "mixture_cure_model",
+        "functions": [],
+        "classes": [
+          "MixtureCureModel"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "generate_datasets",
+        "functions": [
+          "constant_",
+          "constant_coefficients",
+          "construct_survival_curves",
+          "cumulative_integral",
+          "exp_comp_",
+          "exponential_survival_data",
+          "generate_covariates",
+          "generate_hazard_rates",
+          "generate_observational_matrix",
+          "generate_random_lifetimes",
+          "inverseSq_",
+          "log_",
+          "periodic_",
+          "piecewise_exponential_survival_data",
+          "right_censor_lifetimes",
+          "time_varying_coefficients"
+        ],
+        "classes": [
+          "coeff_func"
+        ],
+        "function_signatures": {
+          "piecewise_exponential_survival_data": [
+            "n",
+            "breakpoints",
+            "lambdas"
+          ],
+          "exponential_survival_data": [
+            "n",
+            "cr",
+            "scale"
+          ],
+          "exp_comp_": [
+            "t",
+            "alpha",
+            "beta"
+          ],
+          "log_": [
+            "t",
+            "alpha",
+            "beta"
+          ],
+          "inverseSq_": [
+            "t",
+            "alpha",
+            "beta"
+          ],
+          "periodic_": [
+            "t",
+            "alpha",
+            "beta"
+          ],
+          "constant_": [
+            "t",
+            "alpha",
+            "beta"
+          ],
+          "right_censor_lifetimes": [
+            "lifetimes",
+            "max_",
+            "min_"
+          ],
+          "generate_covariates": [
+            "n",
+            "d",
+            "n_binary",
+            "p"
+          ],
+          "constant_coefficients": [
+            "d",
+            "timelines",
+            "constant",
+            "independent"
+          ],
+          "time_varying_coefficients": [
+            "d",
+            "timelines",
+            "constant",
+            "independent",
+            "randgen"
+          ],
+          "generate_hazard_rates": [
+            "n",
+            "d",
+            "timelines",
+            "constant",
+            "independent",
+            "n_binary",
+            "model"
+          ],
+          "generate_random_lifetimes": [
+            "hazard_rates",
+            "timelines",
+            "size",
+            "censor"
+          ],
+          "generate_observational_matrix": [
+            "n",
+            "d",
+            "timelines",
+            "constant",
+            "independent",
+            "n_binary",
+            "model"
+          ],
+          "cumulative_integral": [
+            "fx",
+            "x"
+          ],
+          "construct_survival_curves": [
+            "hazard_rates",
+            "timelines"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "plotting",
+        "functions": [
+          "add_at_risk_counts",
+          "cdf_plot",
+          "create_dataframe_slicer",
+          "create_scipy_stats_model_from_lifelines_model",
+          "get_distribution_name_of_lifelines_model",
+          "is_latex_enabled",
+          "loglogs_plot",
+          "move_spines",
+          "plot_interval_censored_lifetimes",
+          "plot_lifetimes",
+          "qq_plot",
+          "remove_spines",
+          "remove_ticks",
+          "rmst_plot",
+          "set_kwargs_color",
+          "set_kwargs_drawstyle",
+          "set_kwargs_label"
+        ],
+        "classes": [
+          "PlotEstimateConfig"
+        ],
+        "function_signatures": {
+          "get_distribution_name_of_lifelines_model": [
+            "model"
+          ],
+          "create_scipy_stats_model_from_lifelines_model": [
+            "model"
+          ],
+          "cdf_plot": [
+            "model",
+            "timeline",
+            "ax"
+          ],
+          "rmst_plot": [
+            "model",
+            "model2",
+            "t",
+            "ax",
+            "text_position"
+          ],
+          "qq_plot": [
+            "model",
+            "ax",
+            "scatter_color"
+          ],
+          "is_latex_enabled": [],
+          "remove_spines": [
+            "ax",
+            "sides"
+          ],
+          "move_spines": [
+            "ax",
+            "sides",
+            "dists"
+          ],
+          "remove_ticks": [
+            "ax",
+            "x",
+            "y"
+          ],
+          "add_at_risk_counts": [],
+          "plot_interval_censored_lifetimes": [
+            "lower_bound",
+            "upper_bound",
+            "entry",
+            "left_truncated",
+            "sort_by_lower_bound",
+            "event_observed_color",
+            "event_right_censored_color",
+            "ax"
+          ],
+          "plot_lifetimes": [
+            "durations",
+            "event_observed",
+            "entry",
+            "left_truncated",
+            "sort_by_duration",
+            "event_observed_color",
+            "event_censored_color",
+            "ax"
+          ],
+          "set_kwargs_color": [
+            "kwargs"
+          ],
+          "set_kwargs_drawstyle": [
+            "kwargs",
+            "default"
+          ],
+          "set_kwargs_label": [
+            "kwargs",
+            "cls"
+          ],
+          "create_dataframe_slicer": [
+            "iloc",
+            "loc",
+            "timeline"
+          ],
+          "loglogs_plot": [
+            "cls",
+            "loc",
+            "iloc",
+            "show_censors",
+            "censor_styles",
+            "ax"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "exceptions",
+        "functions": [],
+        "classes": [
+          "ApproximationWarning",
+          "ConvergenceError",
+          "ConvergenceWarning",
+          "ProportionalHazardAssumptionError",
+          "StatError",
+          "StatisticalWarning"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "statistics",
+        "functions": [
+          "difference_of_restricted_mean_survival_time_test",
+          "logrank_test",
+          "multivariate_logrank_test",
+          "pairwise_logrank_test",
+          "power_under_cph",
+          "proportional_hazard_test",
+          "sample_size_necessary_under_cph",
+          "survival_difference_at_fixed_point_in_time_test"
+        ],
+        "classes": [
+          "StatisticalResult",
+          "TimeTransformers"
+        ],
+        "function_signatures": {
+          "sample_size_necessary_under_cph": [
+            "power",
+            "ratio_of_participants",
+            "p_exp",
+            "p_con",
+            "postulated_hazard_ratio",
+            "alpha"
+          ],
+          "power_under_cph": [
+            "n_exp",
+            "n_con",
+            "p_exp",
+            "p_con",
+            "postulated_hazard_ratio",
+            "alpha"
+          ],
+          "survival_difference_at_fixed_point_in_time_test": [
+            "point_in_time",
+            "fitterA",
+            "fitterB"
+          ],
+          "logrank_test": [
+            "durations_A",
+            "durations_B",
+            "event_observed_A",
+            "event_observed_B",
+            "t_0",
+            "weights_A",
+            "weights_B",
+            "weightings"
+          ],
+          "pairwise_logrank_test": [
+            "event_durations",
+            "groups",
+            "event_observed",
+            "t_0",
+            "weightings"
+          ],
+          "difference_of_restricted_mean_survival_time_test": [
+            "model1",
+            "model2",
+            "t"
+          ],
+          "multivariate_logrank_test": [
+            "event_durations",
+            "groups",
+            "event_observed",
+            "weights",
+            "t_0",
+            "weightings"
+          ],
+          "proportional_hazard_test": [
+            "fitted_cox_model",
+            "training_df",
+            "time_transform",
+            "precomputed_residuals"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "calibration",
+        "functions": [
+          "survival_probability_calibration"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "survival_probability_calibration": [
+            "model",
+            "df",
+            "t0",
+            "ax"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "datasets",
+        "functions": [
+          "load_c_botulinum_lag_phase",
+          "load_canadian_senators",
+          "load_dd",
+          "load_dfcv",
+          "load_diabetes",
+          "load_g3",
+          "load_gbsg2",
+          "load_holly_molly_polly",
+          "load_kidney_transplant",
+          "load_larynx",
+          "load_lcd",
+          "load_leukemia",
+          "load_lung",
+          "load_lupus",
+          "load_lymph_node",
+          "load_lymphoma",
+          "load_mice",
+          "load_multicenter_aids_cohort_study",
+          "load_nh4",
+          "load_panel_test",
+          "load_psychiatric_patients",
+          "load_recur",
+          "load_regression_dataset",
+          "load_rossi",
+          "load_stanford_heart_transplants",
+          "load_static_test",
+          "load_waltons"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "load_recur": [],
+          "load_multicenter_aids_cohort_study": [],
+          "load_holly_molly_polly": [],
+          "load_leukemia": [],
+          "load_canadian_senators": [],
+          "load_dd": [],
+          "load_kidney_transplant": [],
+          "load_larynx": [],
+          "load_lung": [],
+          "load_panel_test": [],
+          "load_psychiatric_patients": [],
+          "load_static_test": [],
+          "load_lcd": [],
+          "load_nh4": [],
+          "load_waltons": [],
+          "load_rossi": [],
+          "load_regression_dataset": [],
+          "load_g3": [],
+          "load_stanford_heart_transplants": [],
+          "load_gbsg2": [],
+          "load_dfcv": [],
+          "load_lymphoma": [],
+          "load_diabetes": [],
+          "load_lupus": [],
+          "load_lymph_node": [],
+          "load_c_botulinum_lag_phase": [],
+          "load_mice": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.utils",
+        "module": "lowess",
+        "functions": [
+          "lowess"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "lowess": [
+            "x",
+            "y",
+            "f",
+            "iterations"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "utils",
+        "functions": [
+          "add_covariate_to_timeline",
+          "check_complete_separation",
+          "check_complete_separation_close_to_perfect_correlation",
+          "check_complete_separation_low_variance",
+          "check_dimensions",
+          "check_entry_times",
+          "check_for_immediate_deaths",
+          "check_for_instantaneous_events_at_death_time",
+          "check_for_instantaneous_events_at_time_zero",
+          "check_for_nonnegative_intervals",
+          "check_for_numeric_dtypes_or_raise",
+          "check_for_overlapping_intervals",
+          "check_low_var",
+          "check_nans_or_infs",
+          "check_positivity",
+          "check_scaling",
+          "coalesce",
+          "covariates_from_event_matrix",
+          "datetimes_to_durations",
+          "epanechnikov_kernel",
+          "find_best_parametric_model",
+          "format_exp_floats",
+          "format_floats",
+          "format_p_value",
+          "group_survival_table_from_events",
+          "interpolate_at_times",
+          "interpolate_at_times_and_return_pandas",
+          "inv_normal_cdf",
+          "k_fold_cross_validation",
+          "leading_space",
+          "make_simpliest_hashable",
+          "map_leading_space",
+          "median_survival_times",
+          "normalize",
+          "pass_for_numeric_dtypes_or_raise_array",
+          "pearson_correlation",
+          "qth_survival_time",
+          "qth_survival_times",
+          "quiet_log2",
+          "restricted_mean_survival_time",
+          "ridge_regression",
+          "safe_zip",
+          "survival_events_from_table",
+          "survival_table_from_events",
+          "to_episodic_format",
+          "to_long_format",
+          "unnormalize"
+        ],
+        "classes": [
+          "CensoringType",
+          "CovariateParameterMappings",
+          "DataframeSlicer",
+          "LinearAccumulator",
+          "QuadraticAccumulator",
+          "StepSizer"
+        ],
+        "function_signatures": {
+          "qth_survival_times": [
+            "q",
+            "survival_functions"
+          ],
+          "qth_survival_time": [
+            "q",
+            "model_or_survival_function"
+          ],
+          "median_survival_times": [
+            "model_or_survival_function"
+          ],
+          "restricted_mean_survival_time": [
+            "model_or_survival_function",
+            "t",
+            "return_variance"
+          ],
+          "group_survival_table_from_events": [
+            "groups",
+            "durations",
+            "event_observed",
+            "birth_times",
+            "weights",
+            "limit"
+          ],
+          "survival_table_from_events": [
+            "death_times",
+            "event_observed",
+            "birth_times",
+            "columns",
+            "weights",
+            "collapse",
+            "intervals"
+          ],
+          "survival_events_from_table": [
+            "survival_table",
+            "observed_deaths_col",
+            "censored_col"
+          ],
+          "datetimes_to_durations": [
+            "start_times",
+            "end_times",
+            "fill_date",
+            "freq",
+            "dayfirst",
+            "na_values",
+            "format"
+          ],
+          "coalesce": [],
+          "inv_normal_cdf": [
+            "p"
+          ],
+          "k_fold_cross_validation": [
+            "fitters",
+            "df",
+            "duration_col",
+            "event_col",
+            "k",
+            "scoring_method",
+            "fitter_kwargs",
+            "seed"
+          ],
+          "normalize": [
+            "X",
+            "mean",
+            "std"
+          ],
+          "unnormalize": [
+            "X",
+            "mean",
+            "std"
+          ],
+          "epanechnikov_kernel": [
+            "t",
+            "T",
+            "bandwidth"
+          ],
+          "ridge_regression": [
+            "X",
+            "Y",
+            "c1",
+            "c2",
+            "offset",
+            "ix"
+          ],
+          "pass_for_numeric_dtypes_or_raise_array": [
+            "x"
+          ],
+          "check_scaling": [
+            "df"
+          ],
+          "check_dimensions": [
+            "df"
+          ],
+          "check_for_numeric_dtypes_or_raise": [
+            "df"
+          ],
+          "check_for_nonnegative_intervals": [
+            "start",
+            "stop"
+          ],
+          "check_for_immediate_deaths": [
+            "events",
+            "start",
+            "stop"
+          ],
+          "check_for_instantaneous_events_at_time_zero": [
+            "start",
+            "stop"
+          ],
+          "check_for_instantaneous_events_at_death_time": [
+            "events",
+            "start",
+            "stop"
+          ],
+          "check_for_overlapping_intervals": [
+            "df"
+          ],
+          "check_positivity": [
+            "array"
+          ],
+          "check_low_var": [
+            "df",
+            "prescript",
+            "postscript"
+          ],
+          "check_complete_separation_low_variance": [
+            "df",
+            "events",
+            "event_col"
+          ],
+          "pearson_correlation": [
+            "x",
+            "y"
+          ],
+          "check_entry_times": [
+            "T",
+            "entries"
+          ],
+          "check_complete_separation_close_to_perfect_correlation": [
+            "df",
+            "durations"
+          ],
+          "check_complete_separation": [
+            "df",
+            "events",
+            "durations",
+            "event_col"
+          ],
+          "check_nans_or_infs": [
+            "df_or_array"
+          ],
+          "to_episodic_format": [
+            "df",
+            "duration_col",
+            "event_col",
+            "id_col",
+            "time_gaps"
+          ],
+          "to_long_format": [
+            "df",
+            "duration_col"
+          ],
+          "add_covariate_to_timeline": [
+            "long_form_df",
+            "cv",
+            "id_col",
+            "duration_col",
+            "event_col",
+            "start_col",
+            "stop_col",
+            "add_enum",
+            "overwrite",
+            "cumulative_sum",
+            "cumulative_sum_prefix",
+            "delay"
+          ],
+          "covariates_from_event_matrix": [
+            "df",
+            "id_col"
+          ],
+          "format_p_value": [
+            "decimals"
+          ],
+          "format_exp_floats": [
+            "decimals"
+          ],
+          "format_floats": [
+            "decimals"
+          ],
+          "leading_space": [
+            "s"
+          ],
+          "map_leading_space": [
+            "list"
+          ],
+          "interpolate_at_times": [
+            "df_or_series",
+            "new_times"
+          ],
+          "interpolate_at_times_and_return_pandas": [
+            "df_or_series",
+            "new_times"
+          ],
+          "safe_zip": [
+            "first",
+            "second"
+          ],
+          "make_simpliest_hashable": [
+            "ele"
+          ],
+          "find_best_parametric_model": [
+            "event_times",
+            "event_observed",
+            "scoring_method",
+            "additional_models",
+            "censoring_type",
+            "timeline",
+            "alpha",
+            "ci_labels",
+            "entry",
+            "weights",
+            "show_progress"
+          ],
+          "quiet_log2": [
+            "p"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.utils",
+        "module": "concordance",
+        "functions": [
+          "concordance_index",
+          "naive_concordance_index",
+          "somers_d"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "somers_d": [
+            "event_times",
+            "x",
+            "event_observed"
+          ],
+          "concordance_index": [
+            "event_times",
+            "predicted_scores",
+            "event_observed"
+          ],
+          "naive_concordance_index": [
+            "event_times",
+            "predicted_event_times",
+            "event_observed"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.utils",
+        "module": "printer",
+        "functions": [],
+        "classes": [
+          "Printer"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.utils",
+        "module": "safe_exp",
+        "functions": [
+          "safe_exp",
+          "safe_exp_vjp"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "safe_exp_vjp": [
+            "ans",
+            "x"
+          ],
+          "safe_exp": [
+            "x"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "mixture_cure_fitter",
+        "functions": [],
+        "classes": [
+          "MixtureCureFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "exponential_fitter",
+        "functions": [],
+        "classes": [
+          "ExponentialFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "aalen_johansen_fitter",
+        "functions": [],
+        "classes": [
+          "AalenJohansenFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "breslow_fleming_harrington_fitter",
+        "functions": [],
+        "classes": [
+          "BreslowFlemingHarringtonFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "mixins",
+        "functions": [],
+        "classes": [
+          "ProportionalHazardMixin",
+          "SplineFitterMixin"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "nelson_aalen_fitter",
+        "functions": [],
+        "classes": [
+          "NelsonAalenFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "log_normal_aft_fitter",
+        "functions": [],
+        "classes": [
+          "LogNormalAFTFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "piecewise_exponential_regression_fitter",
+        "functions": [],
+        "classes": [
+          "PiecewiseExponentialRegressionFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines",
+        "module": "fitters",
+        "functions": [],
+        "classes": [
+          "BaseFitter",
+          "KnownModelParametricUnivariateFitter",
+          "NonParametricUnivariateFitter",
+          "ParametericAFTRegressionFitter",
+          "ParametricRegressionFitter",
+          "ParametricUnivariateFitter",
+          "RegressionFitter",
+          "SemiParametricRegressionFitter",
+          "UnivariateFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "log_logistic_fitter",
+        "functions": [],
+        "classes": [
+          "LogLogisticFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "weibull_fitter",
+        "functions": [],
+        "classes": [
+          "WeibullFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "piecewise_exponential_fitter",
+        "functions": [],
+        "classes": [
+          "PiecewiseExponentialFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "coxph_fitter",
+        "functions": [],
+        "classes": [
+          "CoxPHFitter",
+          "ParametricCoxModelFitter",
+          "ParametricPiecewiseBaselinePHFitter",
+          "ParametricSplinePHFitter",
+          "SemiParametricPHFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "generalized_gamma_fitter",
+        "functions": [],
+        "classes": [
+          "GeneralizedGammaFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "aalen_additive_fitter",
+        "functions": [],
+        "classes": [
+          "AalenAdditiveFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "log_logistic_aft_fitter",
+        "functions": [],
+        "classes": [
+          "LogLogisticAFTFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "crc_spline_fitter",
+        "functions": [],
+        "classes": [
+          "CRCSplineFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "cox_time_varying_fitter",
+        "functions": [],
+        "classes": [
+          "CoxTimeVaryingFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "npmle",
+        "functions": [
+          "E_step_M_step",
+          "check_convergence",
+          "create_observation_intervals",
+          "create_turnbull_intervals",
+          "create_turnbull_lookup",
+          "cumulative_sum",
+          "expectation_maximization_fit",
+          "is_subset",
+          "log_likelihood",
+          "log_odds",
+          "npmle",
+          "npmle_compute_confidence_intervals",
+          "probs",
+          "reconstruct_survival_function",
+          "scipy_minimize_fit",
+          "temper"
+        ],
+        "classes": [
+          "min_max"
+        ],
+        "function_signatures": {
+          "temper": [
+            "i",
+            "optimize"
+          ],
+          "E_step_M_step": [
+            "observation_intervals",
+            "p_old",
+            "turnbull_interval_lookup",
+            "weights",
+            "i",
+            "optimize"
+          ],
+          "cumulative_sum": [
+            "p"
+          ],
+          "create_turnbull_intervals": [
+            "left",
+            "right"
+          ],
+          "is_subset": [
+            "query_interval",
+            "super_interval"
+          ],
+          "create_turnbull_lookup": [
+            "turnbull_intervals",
+            "observation_intervals"
+          ],
+          "check_convergence": [
+            "p_new",
+            "p_old",
+            "turnbull_lookup",
+            "weights",
+            "tol",
+            "i",
+            "verbose"
+          ],
+          "create_observation_intervals": [
+            "obs"
+          ],
+          "log_odds": [
+            "p"
+          ],
+          "probs": [
+            "log_odds"
+          ],
+          "npmle": [
+            "left",
+            "right",
+            "tol",
+            "weights",
+            "verbose",
+            "max_iter",
+            "optimize",
+            "fit_method"
+          ],
+          "scipy_minimize_fit": [
+            "turnbull_interval_lookup",
+            "turnbull_intervals",
+            "weights",
+            "tol",
+            "verbose"
+          ],
+          "expectation_maximization_fit": [
+            "observation_intervals",
+            "turnbull_intervals",
+            "turnbull_lookup",
+            "weights",
+            "tol",
+            "max_iter",
+            "optimize",
+            "verbose"
+          ],
+          "log_likelihood": [
+            "p",
+            "turnbull_interval_lookup",
+            "weights"
+          ],
+          "reconstruct_survival_function": [
+            "probabilities",
+            "turnbull_intervals",
+            "timeline",
+            "label"
+          ],
+          "npmle_compute_confidence_intervals": [
+            "left",
+            "right",
+            "mle_",
+            "alpha",
+            "samples"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "spline_fitter",
+        "functions": [],
+        "classes": [
+          "SplineFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "weibull_aft_fitter",
+        "functions": [],
+        "classes": [
+          "WeibullAFTFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "generalized_gamma_regression_fitter",
+        "functions": [],
+        "classes": [
+          "GeneralizedGammaRegressionFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "kaplan_meier_fitter",
+        "functions": [],
+        "classes": [
+          "KaplanMeierFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "lifelines.fitters",
+        "module": "log_normal_fitter",
+        "functions": [],
+        "classes": [
+          "LogNormalFitter"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy",
+        "pandas",
+        "matplotlib",
+        "autograd",
+        "autograd-gamma",
+        "formulaic"
+      ],
+      "optional": [
+        "pytest",
+        "sphinx",
+        "jupyter",
+        "nbconvert"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.94,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/CamDavidsonPilon/lifelines",
+    "repo_name": "lifelines",
+    "error": "DeepWiki analysis failed",
+    "model": "gpt-5.3-codex",
+    "source": "llm_direct_analysis",
+    "success": false
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-5.3-codex"
+  },
+  "risk": {
+    "import_feasibility": 0.94,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

lifelines/mcp_output/diff_report.md

@@ -0,0 +1,142 @@
+# Difference Report — **lifelines**  
+**Generated:** 2026-03-12 08:11:18  
+**Repository:** `lifelines`  
+**Project Type:** Python library  
+**Scope:** Basic functionality  
+**Intrusiveness:** None  
+**Workflow Status:** ✅ Success  
+**Test Status:** ❌ Failed  
+
+---
+
+## 1) Project Overview
+
+This update for the `lifelines` Python library appears to introduce **new assets only** with no edits to existing files, indicating a low-risk, additive change profile from a source-control perspective.
+
+### Change Summary
+- **New files:** 8  
+- **Modified files:** 0  
+- **Deleted files:** 0 (not reported)  
+- **Net impact:** Additive only
+
+---
+
+## 2) Difference Analysis
+
+## 2.1 File-Level Delta
+Given the provided metadata:
+- The change set consists entirely of **8 newly added files**.
+- No existing modules or logic were directly altered (`0 modified`), reducing regression surface in current code paths.
+
+## 2.2 Functional Impact (Expected)
+Because this is a **basic functionality** update and no existing files were modified, likely scenarios include:
+- Introduction of new helper modules/utilities
+- New tests, examples, docs, or configuration files
+- Optional feature scaffolding not yet integrated into active runtime paths
+
+Without per-file listing, runtime impact is assumed **low-to-moderate** unless new files are imported automatically by package init or build tooling.
+
+---
+
+## 3) Technical Analysis
+
+## 3.1 Risk Assessment
+- **Code integration risk:** Low (no modified files)
+- **Build/pipeline risk:** Medium (tests failed despite workflow success)
+- **Release readiness risk:** Medium to High until failing tests are resolved
+
+## 3.2 CI Interpretation
+A successful workflow with failed tests usually means:
+- CI pipeline executed correctly
+- Validation gates detected functional or environmental issues
+
+Potential root causes:
+1. New tests added with unmet assumptions
+2. Environment/version mismatch (Python, dependencies, OS)
+3. Packaging/import side effects from newly introduced files
+4. Incomplete implementation merged with placeholder tests
+
+## 3.3 Quality Signals
+- ✅ Process signal: automation triggered and completed
+- ⚠️ Product signal: test suite not healthy
+- ⚠️ Governance signal: should not promote to production/release tags until green tests
+
+---
+
+## 4) Recommendations & Improvements
+
+## 4.1 Immediate Actions (High Priority)
+1. **Collect failing test logs** and classify by:
+   - deterministic failures
+   - flaky/environmental failures
+2. **Map failures to new files** to confirm direct causality.
+3. **Run tests locally** in CI-equivalent environment:
+   - pinned Python version
+   - locked dependency set
+4. **Block release** until tests pass (or temporarily quarantine known flaky tests with documented rationale).
+
+## 4.2 Short-Term Stabilization
+- Add/verify:
+  - Type checks (`mypy`/pyright if used)
+  - Linting consistency (`ruff`, `flake8`, etc.)
+  - Import-time smoke tests for new modules
+- Ensure new files are correctly included/excluded in:
+  - `pyproject.toml` / packaging config
+  - test discovery patterns
+  - docs build steps
+
+## 4.3 Process Improvements
+- Enforce branch protection requiring:
+  - passing tests
+  - required checks before merge
+- Add CI matrix for key supported Python versions to catch compatibility regressions earlier.
+
+---
+
+## 5) Deployment Information
+
+## 5.1 Current Deployment Readiness
+- **Status:** Not release-ready  
+- **Reason:** Test suite failed
+
+## 5.2 Recommended Deployment Decision
+- **Do not deploy/publish** this revision to package index or production consumers.
+- Promote only after:
+  1. failing tests are resolved,
+  2. full CI passes,
+  3. optional sanity check release (internal/pre-release tag) succeeds.
+
+## 5.3 Rollback/Recovery
+Since no existing files were modified, rollback is straightforward:
+- Revert the commit(s) introducing the 8 new files if urgent stabilization is needed.
+
+---
+
+## 6) Future Planning
+
+## 6.1 Near-Term (Next 1–2 iterations)
+- Achieve 100% pass rate for mandatory test suite.
+- Add targeted regression tests specifically covering newly added file behaviors.
+- Improve failure observability (clearer test naming, richer CI artifacts).
+
+## 6.2 Mid-Term
+- Introduce change-impact templates in PRs:
+  - runtime impact
+  - packaging impact
+  - test impact
+- Add lightweight release checklist for Python library updates:
+  - install test
+  - import test
+  - minimal API smoke test
+
+## 6.3 Long-Term
+- Strengthen quality gates with:
+  - mutation/property-based testing for critical paths
+  - dependency update automation with compatibility validation
+  - trend monitoring for flaky tests and mean time to fix
+
+---
+
+## 7) Executive Summary
+
+This revision is an **additive-only update** (`8 new`, `0 modified`) with **low direct code intrusion** but **failed tests**, making it **unsuitable for release** in its current state. The primary priority is to triage and fix the failing test cases, validate in CI-equivalent environments, and only then proceed with deployment.

lifelines/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,333 @@
+import os
+import sys
+import importlib
+import traceback
+from typing import Any, Dict, Optional, Tuple
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+sys.path.insert(0, source_path)
+
+
+class Adapter:
+    """
+    MCP Import Mode Adapter for the lifelines repository.
+
+    This adapter attempts to import and expose selected classes/functions discovered
+    by repository analysis. It supports graceful fallback when imports fail and returns
+    unified dictionary responses for every public method.
+    """
+
+    # -------------------------------------------------------------------------
+    # Initialization and Module Management
+    # -------------------------------------------------------------------------
+    def __init__(self) -> None:
+        self.mode = "import"
+        self._modules: Dict[str, Any] = {}
+        self._symbols: Dict[str, Any] = {}
+        self._import_errors: Dict[str, str] = {}
+        self._initialize_imports()
+
+    def _ok(self, data: Optional[Dict[str, Any]] = None, message: str = "Success") -> Dict[str, Any]:
+        payload = {"status": "success", "mode": self.mode, "message": message}
+        if data:
+            payload.update(data)
+        return payload
+
+    def _err(self, message: str, guidance: Optional[str] = None, details: Optional[str] = None) -> Dict[str, Any]:
+        payload = {"status": "error", "mode": self.mode, "message": message}
+        if guidance:
+            payload["guidance"] = guidance
+        if details:
+            payload["details"] = details
+        return payload
+
+    def _initialize_imports(self) -> None:
+        """
+        Attempt to import all identified modules/symbols from analysis results.
+        Uses full module paths (with source prefix removed due to sys.path setup).
+        """
+        targets = [
+            ("conftest", "block"),
+            ("docs.conftest", "tempdir"),
+            ("docs.conf", "setup"),
+            ("examples.crowther_royston_clements_splines", "generate_data"),
+            ("examples.crowther_royston_clements_splines", "CRCSplineFitter"),
+            ("examples.royston_parmar_splines", "PHSplineFitter"),
+            ("examples.royston_parmar_splines", "POSplineFitter"),
+            ("examples.royston_parmar_splines", "SplineFitter"),
+            ("examples.cure_model", "CureModel"),
+            ("examples.haft_model", "HAFT"),
+            ("examples.copula_frailty_weibull_model", "CopulaFrailtyWeilbullModel"),
+            ("examples.mixture_cure_model", "MixtureCureModel"),
+        ]
+
+        for module_path, symbol_name in targets:
+            try:
+                module = self._modules.get(module_path)
+                if module is None:
+                    module = importlib.import_module(module_path)
+                    self._modules[module_path] = module
+                symbol = getattr(module, symbol_name)
+                self._symbols[f"{module_path}.{symbol_name}"] = symbol
+            except Exception as e:
+                self._import_errors[f"{module_path}.{symbol_name}"] = f"{type(e).__name__}: {e}"
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Report import availability and fallback readiness.
+
+        Returns:
+            Unified status dictionary with import summary and actionable guidance.
+        """
+        available = sorted(self._symbols.keys())
+        failed = dict(self._import_errors)
+        if failed:
+            return self._ok(
+                {
+                    "available_symbols": available,
+                    "failed_symbols": failed,
+                    "fallback_ready": True,
+                },
+                message="Partial import success. Fallback mode is available for missing symbols.",
+            )
+        return self._ok(
+            {
+                "available_symbols": available,
+                "failed_symbols": {},
+                "fallback_ready": True,
+            },
+            message="All identified symbols imported successfully.",
+        )
+
+    def _resolve_symbol(self, module_path: str, symbol_name: str) -> Tuple[Optional[Any], Optional[Dict[str, Any]]]:
+        key = f"{module_path}.{symbol_name}"
+        symbol = self._symbols.get(key)
+        if symbol is not None:
+            return symbol, None
+        err = self._import_errors.get(key, "Unknown import issue.")
+        return None, self._err(
+            message=f"Requested symbol is unavailable: {key}",
+            guidance=(
+                "Verify repository source is present under the expected 'source' directory, "
+                "install required dependencies (numpy, scipy, pandas, matplotlib, autograd, "
+                "autograd-gamma, formulaic), and retry health_check()."
+            ),
+            details=err,
+        )
+
+    def _instantiate(self, module_path: str, class_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        cls, err = self._resolve_symbol(module_path, class_name)
+        if err:
+            return err
+        try:
+            instance = cls(*args, **kwargs)
+            return self._ok({"instance": instance, "class": f"{module_path}.{class_name}"}, message="Instance created.")
+        except Exception as e:
+            return self._err(
+                message=f"Failed to instantiate class: {module_path}.{class_name}",
+                guidance="Check constructor arguments and dependency availability.",
+                details=f"{type(e).__name__}: {e}",
+            )
+
+    def _call(self, module_path: str, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        fn, err = self._resolve_symbol(module_path, function_name)
+        if err:
+            return err
+        try:
+            result = fn(*args, **kwargs)
+            return self._ok({"result": result, "function": f"{module_path}.{function_name}"}, message="Function executed.")
+        except Exception as e:
+            return self._err(
+                message=f"Failed to execute function: {module_path}.{function_name}",
+                guidance="Review function parameters and input data shapes/types.",
+                details=f"{type(e).__name__}: {e}",
+            )
+
+    # -------------------------------------------------------------------------
+    # Functions from discovered modules
+    # -------------------------------------------------------------------------
+    def call_conftest_block(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call conftest.block(*args, **kwargs).
+
+        Parameters:
+            *args: Positional arguments forwarded to conftest.block.
+            **kwargs: Keyword arguments forwarded to conftest.block.
+
+        Returns:
+            Unified status dictionary with function result or actionable error.
+        """
+        return self._call("conftest", "block", *args, **kwargs)
+
+    def call_docs_conftest_tempdir(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call docs.conftest.tempdir(*args, **kwargs).
+
+        Parameters:
+            *args: Positional arguments forwarded to docs.conftest.tempdir.
+            **kwargs: Keyword arguments forwarded to docs.conftest.tempdir.
+
+        Returns:
+            Unified status dictionary with function result or actionable error.
+        """
+        return self._call("docs.conftest", "tempdir", *args, **kwargs)
+
+    def call_docs_conf_setup(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call docs.conf.setup(*args, **kwargs).
+
+        Parameters:
+            *args: Positional arguments forwarded to docs.conf.setup.
+            **kwargs: Keyword arguments forwarded to docs.conf.setup.
+
+        Returns:
+            Unified status dictionary with function result or actionable error.
+        """
+        return self._call("docs.conf", "setup", *args, **kwargs)
+
+    def call_generate_data(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call examples.crowther_royston_clements_splines.generate_data(*args, **kwargs).
+
+        Parameters:
+            *args: Positional arguments forwarded to generate_data.
+            **kwargs: Keyword arguments forwarded to generate_data.
+
+        Returns:
+            Unified status dictionary with generated data or actionable error.
+        """
+        return self._call("examples.crowther_royston_clements_splines", "generate_data", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Class instance factory methods
+    # -------------------------------------------------------------------------
+    def create_crc_spline_fitter(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.crowther_royston_clements_splines.CRCSplineFitter.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.crowther_royston_clements_splines", "CRCSplineFitter", *args, **kwargs)
+
+    def create_ph_spline_fitter(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.royston_parmar_splines.PHSplineFitter.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.royston_parmar_splines", "PHSplineFitter", *args, **kwargs)
+
+    def create_po_spline_fitter(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.royston_parmar_splines.POSplineFitter.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.royston_parmar_splines", "POSplineFitter", *args, **kwargs)
+
+    def create_spline_fitter(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.royston_parmar_splines.SplineFitter.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.royston_parmar_splines", "SplineFitter", *args, **kwargs)
+
+    def create_cure_model(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.cure_model.CureModel.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.cure_model", "CureModel", *args, **kwargs)
+
+    def create_haft_model(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.haft_model.HAFT.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.haft_model", "HAFT", *args, **kwargs)
+
+    def create_copula_frailty_weilbull_model(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.copula_frailty_weibull_model.CopulaFrailtyWeilbullModel.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate(
+            "examples.copula_frailty_weibull_model",
+            "CopulaFrailtyWeilbullModel",
+            *args,
+            **kwargs,
+        )
+
+    def create_mixture_cure_model(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create an instance of examples.mixture_cure_model.MixtureCureModel.
+
+        Parameters:
+            *args: Positional constructor arguments.
+            **kwargs: Keyword constructor arguments.
+
+        Returns:
+            Unified status dictionary containing created instance or actionable error.
+        """
+        return self._instantiate("examples.mixture_cure_model", "MixtureCureModel", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Utility for runtime troubleshooting
+    # -------------------------------------------------------------------------
+    def debug_trace(self, exc: BaseException) -> Dict[str, Any]:
+        """
+        Return a structured traceback payload for debugging adapter-level exceptions.
+
+        Parameters:
+            exc: Exception object to format.
+
+        Returns:
+            Unified error dictionary with traceback details.
+        """
+        return self._err(
+            message="Adapter debug trace generated.",
+            guidance="Inspect details and fix module paths, missing dependencies, or invalid inputs.",
+            details="".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        )

lifelines/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

lifelines/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,398 @@
+import os
+import sys
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+from conftest import block
+from docs.conftest import tempdir
+from docs.conf import setup
+from examples.crowther_royston_clements_splines import generate_data, CRCSplineFitter
+from examples.royston_parmar_splines import PHSplineFitter, POSplineFitter, SplineFitter
+from examples.cure_model import CureModel
+from examples.haft_model import HAFT
+from examples.copula_frailty_weibull_model import CopulaFrailtyWeilbullModel
+from examples.mixture_cure_model import MixtureCureModel
+
+mcp = FastMCP("unknown_service")
+
+
+@mcp.tool(name="block", description="Auto-wrapped function block")
+def block(payload: dict):
+    try:
+        if block is None:
+            return {"success": False, "result": None, "error": "Function block is not available"}
+        result = block(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="tempdir", description="Auto-wrapped function tempdir")
+def tempdir(payload: dict):
+    try:
+        if tempdir is None:
+            return {"success": False, "result": None, "error": "Function tempdir is not available"}
+        result = tempdir(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="setup", description="Auto-wrapped function setup")
+def setup(payload: dict):
+    try:
+        if setup is None:
+            return {"success": False, "result": None, "error": "Function setup is not available"}
+        result = setup(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="generate_data", description="Auto-wrapped function generate_data")
+def generate_data(payload: dict):
+    try:
+        if generate_data is None:
+            return {"success": False, "result": None, "error": "Function generate_data is not available"}
+        result = generate_data(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="crcsplinefitter", description="CRCSplineFitter class")
+def crcsplinefitter(*args, **kwargs):
+    """CRCSplineFitter class"""
+    try:
+        if CRCSplineFitter is None:
+            return {"success": False, "result": None, "error": "Class CRCSplineFitter is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = CRCSplineFitter(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="phsplinefitter", description="PHSplineFitter class")
+def phsplinefitter(*args, **kwargs):
+    """PHSplineFitter class"""
+    try:
+        if PHSplineFitter is None:
+            return {"success": False, "result": None, "error": "Class PHSplineFitter is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = PHSplineFitter(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="posplinefitter", description="POSplineFitter class")
+def posplinefitter(*args, **kwargs):
+    """POSplineFitter class"""
+    try:
+        if POSplineFitter is None:
+            return {"success": False, "result": None, "error": "Class POSplineFitter is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = POSplineFitter(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="splinefitter", description="SplineFitter class")
+def splinefitter(*args, **kwargs):
+    """SplineFitter class"""
+    try:
+        if SplineFitter is None:
+            return {"success": False, "result": None, "error": "Class SplineFitter is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = SplineFitter(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="curemodel", description="CureModel class")
+def curemodel(*args, **kwargs):
+    """CureModel class"""
+    try:
+        if CureModel is None:
+            return {"success": False, "result": None, "error": "Class CureModel is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = CureModel(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="haft", description="HAFT class")
+def haft(*args, **kwargs):
+    """HAFT class"""
+    try:
+        if HAFT is None:
+            return {"success": False, "result": None, "error": "Class HAFT is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = HAFT(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="copulafrailtyweilbullmodel", description="CopulaFrailtyWeilbullModel class")
+def copulafrailtyweilbullmodel(*args, **kwargs):
+    """CopulaFrailtyWeilbullModel class"""
+    try:
+        if CopulaFrailtyWeilbullModel is None:
+            return {"success": False, "result": None, "error": "Class CopulaFrailtyWeilbullModel is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = CopulaFrailtyWeilbullModel(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="mixturecuremodel", description="MixtureCureModel class")
+def mixturecuremodel(*args, **kwargs):
+    """MixtureCureModel class"""
+    try:
+        if MixtureCureModel is None:
+            return {"success": False, "result": None, "error": "Class MixtureCureModel is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = MixtureCureModel(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+
+def create_app():
+    """Create and return FastMCP application instance"""
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)

lifelines/mcp_output/requirements.txt

@@ -0,0 +1,11 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+numpy
+scipy
+pandas
+matplotlib
+autograd
+autograd-gamma
+formulaic

lifelines/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

lifelines/mcp_output/workflow_summary.json

@@ -0,0 +1,224 @@
+{
+  "repository": {
+    "name": "lifelines",
+    "url": "https://github.com/CamDavidsonPilon/lifelines",
+    "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/lifelines",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1773273949.5239081,
+    "end_time": 1773274139.770443,
+    "duration": 190.24653482437134,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 5,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.lifelines",
+        "source.lifelines.datasets",
+        "source.lifelines.fitters",
+        "source.lifelines.tests",
+        "source.lifelines.utils"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": false,
+      "setup_cfg": false,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.94,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/CamDavidsonPilon/lifelines",
+      "repo_name": "lifelines",
+      "error": "DeepWiki analysis failed",
+      "model": "gpt-5.3-codex",
+      "source": "llm_direct_analysis",
+      "success": false
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/lifelines/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "migrate packaging from legacy setup.py to a pyproject.toml build (PEP 517/621) with pinned optional extras for docs/tests",
+    "split oversized modules (especially lifelines/fitters/__init__.py",
+    "coxph_fitter.py",
+    "and test_estimation.py) into smaller focused files to improve maintainability",
+    "strengthen CI by adding a full test matrix (Python versions/OS)",
+    "coverage thresholds",
+    "and wheel/sdist smoke-install checks",
+    "add performance regression benchmarks in CI using existing perf_tests (with baseline tracking for core fitters like CoxPH and KaplanMeier)",
+    "introduce stricter static analysis gates (mypy on key modules",
+    "ruff/flake8",
+    "docstring lint) and fail builds on new violations",
+    "harden API quality by defining/stabilizing public API exports and excluding internal/test/example symbols from generated MCP endpoints",
+    "improve docs with task-oriented guides (time-varying covariates",
+    "left/interval censoring",
+    "model selection) plus runnable notebook tests",
+    "add property-based and numerical-stability tests for edge cases (extreme censoring",
+    "ties",
+    "near-separation",
+    "NaN/inf handling)",
+    "formalize deprecation/versioning policy and automate changelog/release notes from PR labels",
+    "add reproducibility controls across stochastic utilities/tests (global seed strategy and deterministic test fixtures)",
+    "add security and dependency hygiene checks (pip-audit/safety",
+    "Dependabot",
+    "minimal version bounds validation)",
+    "improve plugin robustness with endpoint naming normalization and collision checks (e.g.",
+    "duplicate fitter names)",
+    "and add lightweight architecture docs describing fitter hierarchy",
+    "mixins",
+    "and statistical test design boundaries"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Workflow completed end-to-end with status=success across all planned nodes (download, analysis, env, generate, run, review, finalize).",
+      "Import-based adapter strategy was feasible (import feasibility 0.94, low intrusiveness risk), enabling rapid MCP wrapping.",
+      "Generated MCP service started healthy over stdio and plugin tests passed.",
+      "Repository structure was analyzable via zip fallback despite DeepWiki failure."
+    ],
+    "failure_reasons": [
+      "No hard workflow failure occurred.",
+      "DeepWiki analysis failed (non-blocking) and reduced enrichment quality.",
+      "Original project tests were not validated as passing (original_project.passed=false, empty details), creating confidence gaps in behavioral parity.",
+      "Metrics instrumentation appears incomplete (0 for LOC/size/resource/perf metrics), limiting evidence-based quality assessment."
+    ],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Completed successfully; repo imported via zip fallback (86 files). Exact per-node timing not provided.",
+      "analysis_time": "Completed successfully; medium complexity identified with broad AST-discovered API surface. DeepWiki sub-step failed but analysis continued.",
+      "generation_time": "Completed successfully; MCP scaffold and adapter files generated, but reported generated LOC/size/tool count fields are inconsistent with actual endpoint list.",
+      "test_time": "MCP plugin health checks passed; original project test validation was effectively not executed/recorded (execution_time=0, no test files)."
+    },
+    "resource_usage": {
+      "memory_efficiency": "Undetermined due to missing telemetry (reported 0 MB).",
+      "cpu_efficiency": "Undetermined due to missing telemetry (reported 0%).",
+      "disk_usage": "Low-to-moderate footprint expected from small generated scaffold; reported size metrics are missing/inaccurate."
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 72,
+    "architecture_score": 74,
+    "performance_score": 61,
+    "maintainability_score": 68,
+    "security_score": 85,
+    "scalability_score": 66
+  }
+}

lifelines/source/.coveragerc

@@ -0,0 +1,4 @@
+# .coveragerc to control coverage.py
+[run]
+omit =
+    lifelines/plotting.py

lifelines/source/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: check-ast
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: fix-encoding-pragma
+    -   id: mixed-line-ending
+    -   id: trailing-whitespace
+-   repo: https://github.com/ambv/black
+    rev: 22.8.0
+    hooks:
+    - id: black
+      args: ["--line-length", "130"]

lifelines/source/.prospector.yaml

@@ -0,0 +1,46 @@
+strictness: medium
+
+pylint:
+  options:
+    bad-names: foo,baz,toto,tutu,tata,data
+    # max-args default = 5
+    max-args: 15
+    # max-locals default = 15
+    max-locals: 50
+    # max-branches default = 15
+    max-branches: 16
+  disable:
+    - line-too-long
+    - protected-access
+    - no-value-for-parameter
+    - assignment-from-no-return
+    - invalid-unary-operand-type
+
+pyflakes:
+  disable:
+    - F401
+    - F841
+    # let pylint used-before-assignment handle this
+    - F821
+
+pep8:
+  options:
+    max-line-length: 130
+  disable:
+    - E501
+    - E241
+
+mccabe:
+  options:
+    # max-complexity default = 10
+    max-complexity: 23
+
+pyroma:
+  run: true
+
+pep257:
+  run: false
+
+ignore-paths:
+  - build
+  - benchmarks

lifelines/source/.readthedocs.yaml

@@ -0,0 +1,35 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+    # You can also specify other tool versions:
+    # nodejs: "20"
+    # rust: "1.70"
+    # golang: "1.20"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+  # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs
+  # builder: "dirhtml"
+  # Fail on all warnings to avoid broken references
+  # fail_on_warning: true
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+   install:
+   - requirements: reqs/docs-requirements.txt

lifelines/source/CHANGELOG.md

@@ -0,0 +1,1310 @@
+## Changelog
+
+#### 0.30.3 - 2026-03-05
+ - Revoke the 0.30.2 release and republish as 0.30.3.
+ - Require Python >= 3.11 in package metadata.
+
+#### 0.30.2 - 2026-03-04
+ - Revoke the 0.30.1 release and republish as 0.30.2.
+ - Require Python >= 3.10 in package metadata.
+ - Update Python trove classifiers to `Python :: 3 :: Only` and add explicit support classifiers for Python 3.12, 3.13, and 3.14.
+
+#### 0.30.1 - 2026-02-04
+ - Optimize `AalenJohansenFitter` variance calculation using prefix-sum accumulators; add `LinearAccumulator`/`QuadraticAccumulator` utilities and tests.
+ - Fix `CoxPHFitter` handling when `event_col=None` (sorting and default event vector).
+ - Fix `add_at_risk_counts` for NumPy >= 2.4 scalar conversion; add regression test.
+ - Support Python 3.13 and 3.14.
+
+#### 0.30.0 - 2024-10-29
+ - update dependencies (numpy >= 1.14.0)
+ - fix for `decimal` kwarg not working in StatisticalResult
+
+
+#### 0.29.0 - 2024-06-25
+ - update dependencies (pandas >= 2.1)
+ - update dependencies (scipy >= 1.7)
+
+
+#### 0.28.0 - 2024-01-03
+ - Fixes bins that are far into the future with using `survival_table_from_events`, see #1587
+ - Removed `sklean_adaptor`. It was a terrible hack, and causing more confusion and support debt than I want. This cleans up our API and simplifies the library. ✨ There's no replacement, and I doubt I'll introduce one ✨
+ - Fix pandas>=2.0 compatibility.
+ - Fix overflow issue in NelsonAalenfitter, #1585
+ - officially drop support for < py3.9
+ - update some dependencies (pandas >= 1.2)
+
+#### 0.27.8 - 2023-09-13
+ - Estimators now have `.label` property
+ - Fixed some deprecation warnings
+ - Pinned to numpy < 2.0
+
+#### 0.27.7 - 2023-05-01
+ - `check_assumptions(show_plots=True)` will always show plots, regardless of test outcome. Thanks @nomennominatur!
+ - `lifelines.datasets` is now importable.
+
+#### 0.27.6 - 2023-04-27
+ - Fix for py3.7
+
+#### 0.27.5 - 2023-04-27
+ - Support pandas 2.0+
+
+##### New features
+ - Support py3.11
+
+#### 0.27.4 - 2022-11-16
+
+##### New features
+ - Support py3.11
+
+#### 0.27.3 - 2022-09-25
+
+##### New features
+ - Fixed and silenced a lot of warnings
+
+##### Bug fixes
+ - Migrate to newer Pandas `Styler` for `to_latex`
+
+##### API Changes
+ - There were way too many functions on the summary objects, so I've hidden `to_*` on them.
+
+
+#### 0.27.2 - 2022-09-07
+
+##### Bug fixes
+ - Fixed issue in add_at_risk_table when there were very late entries.
+
+
+#### 0.27.1 - 2022-06-25
+
+##### New features
+ - all `fit_` methods now accept a `fit_options` dict that allows one to pass kwargs to the underlying fitting algorithm.
+
+
+##### API Changes
+ - `step_size` is removed from Cox models `fit`. See `fit_options` above.
+
+##### Bug fixes
+ - fixed Cox models when "trivial" matrix was passed in (one with no covariates)
+
+#### 0.27.0 - 2022-03-15
+
+Dropping Python3.6 support.
+
+##### Bug fixes
+ - Fix late entry in `add_at_risk_counts`.
+
+##### New features
+ - `add_at_risk_counts` has a new flag to determine to use start or end-of-period at risk counts.
+ - new column in fitter's `summary` that display the number the parameter is being compared against.
+
+##### API Changes
+ - `plot_lifetimes`'s `duration` arg has the interpretation of "relative time the subject died (since birth)", instead of the old "time observed for". These interpretations are different when there is late entry.
+
+
+#### 0.26.4 - 2021-11-30
+
+##### New features
+ - adding `weights` to log rank functions
+
+
+#### 0.26.3 - 2021-09-16
+
+##### Bug fixes
+ - Fix using formulas with `CoxPHFitter.score`
+
+
+#### 0.26.2 - 2021-09-15
+
+Error in v0.26.1 deployment
+
+#### 0.26.1 - 2021-09-15
+
+##### API Changes
+ - `t_0` in `logrank_test` now will not remove data, but will instead censor all subjects that experience the event afterwards.
+ - update `status` column in `lifelines.datasets.load_lung` to be more standard coding: 0 is censored, 1 is event.
+
+##### Bug fixes
+ - Fix using formulas with `AalenAdditiveFitter.predict_cumulative_hazard`
+ - Fix using formulas with `CoxPHFitter.score`
+
+
+#### 0.26.0 - 2021-05-26
+
+##### New features
+ - `.BIC_` is now present on fitted models.
+ - `CoxPHFitter` with spline baseline can accept pre-computed knot locations.
+ - Left censoring fitting in KaplanMeierFitter is now "expected". That is, `predict` _always_ predicts the survival function (as does every other model), `confidence_interval_` is _always_ the CI for the survival function (as does every other model), and so on. In summary: the API for estimates doesn't change depending on what your censoring your dataset is.
+
+##### Bug fixes
+ - Fixed an annoying bug where at_risk-table label's were not aligning properly when data spanned large ranges. See merging PR for details.
+ - Fixed a bug in `find_best_parametric_model` where the wrong BIC value was being computed.
+ - Fixed regression bug when using an array as a penalizer in Cox models.
+
+
+#### 0.25.11 - 2021-04-06
+
+##### Bug fixes
+ - Fix integer-valued categorical variables in regression model predictions.
+ - numpy > 1.20 is allowed.
+ - Bug fix in the elastic-net penalty for Cox models that wasn't weighting the terms correctly.
+
+
+#### 0.25.10 - 2021-03-03
+
+##### New features
+ - Better appearance when using a single row to show in `add_at_risk_table`.
+
+
+#### 0.25.9 - 2021-02-04
+
+Small bump in dependencies.
+
+
+#### 0.25.8 - 2021-01-22
+
+Important: we dropped Patsy as our formula framework, and adopted Formulaic. Will the latter is less mature than Patsy, we feel the core capabilities are satisfactory and it provides new opportunities.
+
+##### New features
+ - Parametric models with formulas are able to be serialized now.
+ - a `_scipy_callback` function is available to use in fitting algorithms.
+
+
+#### 0.25.7 - 2020-12-09
+
+##### API Changes
+ - Adding `cumulative_hazard_at_times` to NelsonAalenFitter
+
+
+##### Bug fixes
+ - Fixed error in `CoxPHFitter` when entry time == event time.
+ - Fixed formulas in AFT interval censoring regression.
+ - Fixed `concordance_index_` when no events observed
+ - Fixed label being overwritten in ParametricUnivariate models
+
+
+#### 0.25.6 - 2020-10-26
+
+##### New features
+ - Parametric Cox models can now handle left and interval censoring datasets.
+
+##### Bug fixes
+ - "improved" the output of `add_at_risk_counts` by removing a call to `plt.tight_layout()` - this works better when you are calling `add_at_risk_counts` on multiple axes, but it is recommended you call `plt.tight_layout()` at the very end of your script.
+ - Fix bug in `KaplanMeierFitter`'s interval censoring where max(lower bound) < min(upper bound).
+
+
+#### 0.25.5 - 2020-09-23
+
+##### API Changes
+ - `check_assumptions` now returns a list of list of axes that can be manipulated
+
+##### Bug fixes
+ - fixed error when using `plot_partial_effects` with categorical data in AFT models
+ - improved warning when Hessian matrix contains NaNs.
+ - fixed performance regression in interval censoring fitting in parametric models
+ - `weights` wasn't being applied properly in NPMLE
+
+#### 0.25.4 - 2020-08-26
+
+##### New features
+ - New baseline estimator for Cox models: ``piecewise``
+ - Performance improvements for parametric models `log_likelihood_ratio_test()` and `print_summary()`
+ - Better step-size defaults for Cox model -> more robust convergence.
+
+
+##### Bug fixes
+ - fix `check_assumptions` when using formulas.
+
+
+#### 0.25.3 - 2020-08-24
+
+##### New features
+ - `survival_difference_at_fixed_point_in_time_test` now accepts fitters instead of raw data, meaning that you can use this function on left, right or interval censored data.
+
+##### API Changes
+ - See note on `survival_difference_at_fixed_point_in_time_test` above.
+
+##### Bug fixes
+ - fix `StatisticalResult` printing in notebooks
+ - fix Python error when calling `plot_covariate_groups`
+ - fix dtype mismatches in `plot_partial_effects_on_outcome`.
+
+
+#### 0.25.2 - 2020-08-08
+
+##### New features
+ - Spline `CoxPHFitter` can now use `strata`.
+
+##### API Changes
+ - a small parameterization change of the spline `CoxPHFitter`. The linear term in the spline part was moved to a new `Intercept` term in the `beta_`.
+ - `n_baseline_knots` in the spline `CoxPHFitter` now refers to _all_ knots, and not just interior knots (this was confusing to me, the author.). So add 2 to `n_baseline_knots` to recover the identical model as previously.
+
+##### Bug fixes
+ - fix splines `CoxPHFitter` with  when `predict_hazard` was called.
+ - fix some exception imports I missed.
+ - fix log-likelihood p-value in splines `CoxPHFitter`
+
+
+#### 0.25.1 - 2020-08-01
+
+##### Bug fixes
+ - ok _actually_ ship the out-of-sample calibration code
+ - fix `labels=False` in `add_at_risk_counts`
+ - allow for specific rows to be shown in `add_at_risk_counts`
+ - put `patsy` as a proper dependency.
+ - suppress some Pandas 1.1 warnings.
+
+
+#### 0.25.0 - 2020-07-27
+
+##### New features
+ - Formulas! *lifelines* now supports R-like formulas in regression models. See docs [here](https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#fitting-the-regression).
+ - `plot_covariate_group` now can plot other y-values like hazards and cumulative hazards (default: survival function).
+ - `CoxPHFitter` now accepts late entries via `entry_col`.
+ - `calibration.survival_probability_calibration` now works with out-of-sample data.
+ - `print_summary` now accepts a `column` argument to filter down the displayed values. This helps with clutter in notebooks, latex, or on the terminal.
+ - `add_at_risk_counts` now follows the cool new KMunicate suggestions
+
+
+##### API Changes
+ - With the introduction of formulas, all models can be using formulas under the hood.
+    - For both custom regression models or non-AFT regression models, this means that you no longer need to add a constant column to your DataFrame (instead add a `1` as a formula string in the `regressors` dict). You may also need to remove the T and E columns from `regressors`. I've updated the models in the `\examples` folder with examples of this new model building.
+ - Unfortunately, if using formulas, your model will not be able to be pickled. This is a problem with an upstream library, and I hope to have it resolved in the near future.
+ - `plot_covariate_groups` has been deprecated in favour of `plot_partial_effects_on_outcome`.
+ - The baseline in `plot_covariate_groups` has changed from the *mean* observation (including dummy-encoded categorical variables) to *median* for ordinal (including continuous) and *mode* for categorical.
+ - Previously, *lifelines* used the label `"_intercept"` to when it added a constant column in regressions. To align with Patsy, we are now using `"Intercept"`.
+ - In AFT models, `ancillary_df` kwarg has been renamed to `ancillary`. This reflects the more general use of the kwarg (not always a DataFrame, but could be a boolean or string now, too).
+ - Some column names in datasets shipped with lifelines have changed.
+ - The never used "lifelines.metrics" is deleted.
+ - With the introduction of formulas, `plot_covariate_groups` (now called `plot_partial_effects_on_outcome`) behaves differently for transformed variables. Users no longer need to add "derivatives" features, and encoding is done implicitly. See docs [here](https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#plotting-the-effect-of-varying-a-covariate).
+ - all exceptions and warnings have moved to `lifelines.exceptions`
+
+##### Bug fixes
+ - The p-value of the log-likelihood ratio test for the CoxPHFitter with splines was returning the wrong result because the degrees of freedom was incorrect.
+ - better `print_summary` logic in IDEs and Jupyter exports. Previously it should not be displayed.
+ - p-values have been corrected in the `SplineFitter`. Previously, the "null hypothesis" was no coefficient=0, but coefficient=0.01. This is now set to the former.
+ - fixed NaN bug in `survival_table_from_events` with intervals when no events would occur in a interval.
+
+#### 0.24.16 - 2020-07-09
+
+##### New features
+ - improved algorithm choice for large DataFrames for Cox models. Should see a significant performance boost.
+
+##### Bug fixes
+- fixed `utils.median_survival_time` not accepting Pandas Series.
+
+#### 0.24.15 - 2020-07-07
+
+##### Bug fixes
+- fixed an edge case in `KaplanMeierFitter` where a really late entry would occur after all other population had died.
+- fixed `plot` in `BreslowFlemingtonHarrisFitter`
+- fixed bug where using `conditional_after` and `times` in `CoxPHFitter("spline")` prediction methods would be ignored.
+
+
+#### 0.24.14 - 2020-07-02
+
+##### Bug fixes
+- fixed a bug where using `conditional_after` and `times` in prediction methods would result in a shape error
+- fixed a bug where `score` was not able to be used in splined `CoxPHFitter`
+- fixed a bug where some columns would not be displayed in `print_summary`
+
+#### 0.24.13 - 2020-06-22
+
+##### Bug fixes
+- fixed a bug where `CoxPHFitter` would ignore inputed `alpha` levels for confidence intervals
+- fixed a bug where `CoxPHFitter` would fail with working with `sklearn_adapter`
+
+
+#### 0.24.12 - 2020-06-20
+
+##### New features
+ - improved convergence of `GeneralizedGamma(Regression)Fitter`.
+
+
+#### 0.24.11 - 2020-06-17
+
+##### New features
+ - new spline regression model `CRCSplineFitter` based on the paper "A flexible parametric accelerated failure time model" by Michael J. Crowther, Patrick Royston, Mark Clements.
+ - new survival probability calibration tool `lifelines.calibration.survival_probability_calibration` to help validate regression models. Based on “Graphical calibration curves and the integrated calibration index (ICI) for survival models” by P. Austin, F. Harrell, and D. van Klaveren.
+
+##### API Changes
+ - (and bug fix) scalar parameters in regression models were not being penalized by `penalizer` - we now penalizing everything except intercept terms in linear relationships.
+
+
+#### 0.24.10 - 2020-06-16
+
+##### New features
+ - New improvements when using splines model in CoxPHFitter - it should offer much better prediction and baseline-hazard estimation, including extrapolation and interpolation.
+
+##### API Changes
+ - Related to above: the fitted spline parameters are now available in the `.summary` and `.print_summary` methods.
+
+##### Bug fixes
+- fixed a bug in initialization of some interval-censoring models -> better convergence.
+
+
+#### 0.24.9 - 2020-06-05
+
+##### New features
+ - Faster NPMLE for interval censored data
+ - New weightings available in the `logrank_test`: `wilcoxon`, `tarone-ware`, `peto`, `fleming-harrington`. Thanks @sean-reed
+ - new interval censored dataset: `lifelines.datasets.load_mice`
+
+##### Bug fixes
+ - Cleared up some mislabeling in `plot_loglogs`. Thanks @sean-reed!
+ - tuples are now able to be used as input in univariate models.
+
+#### 0.24.8 - 2020-05-17
+
+##### New features
+ - Non parametric interval censoring is now available, _experimentally_. Not all edge cases are fully checked, and some features are missing. Try it under `KaplanMeierFitter.fit_interval_censoring`
+
+
+#### 0.24.7 - 2020-05-17
+
+##### New features
+ - `find_best_parametric_model` can handle left and interval censoring. Also allows for more fitting options.
+ - `AIC_` is a property on parametric models, and `AIC_partial_` is a property on Cox models.
+ - `penalizer` in all regression models can now be an array instead of a float. This enables new functionality and better
+ control over penalization. This is similar (but not identical) to `penalty.factors` in glmnet in R.
+ - some convergence tweaks which should help recent performance regressions.
+
+#### 0.24.6 - 2020-05-05
+
+##### New features
+ - At the cost of some performance, convergence is improved in many models.
+ - New `lifelines.plotting.plot_interval_censored_lifetimes` for plotting interval censored data - thanks @sean-reed!
+
+##### Bug fixes
+ - fixed bug where `cdf_plot` and `qq_plot` were not factoring in the weights correctly.
+
+#### 0.24.5 - 2020-05-01
+
+##### New features
+ - `plot_lifetimes` accepts pandas Series.
+
+##### Bug fixes
+ - Fixed important bug in interval censoring models. Users using interval censoring are strongly advised to upgrade.
+ - Improved `at_risk_counts` for subplots.
+ - More data validation checks for `CoxTimeVaryingFitter`
+
+#### 0.24.4 - 2020-04-13
+
+##### Bug fixes
+ - Improved stability of interval censoring in parametric models.
+ - setting a dataframe in `ancillary_df` works for interval censoring
+ - `.score` works for interval censored models
+
+#### 0.24.3 - 2020-03-25
+
+##### New features
+ - new `logx` kwarg in plotting curves
+ - PH models have `compute_followup_hazard_ratios` for simulating what the hazard ratio would be at previous times. This is useful because the final hazard ratio is some weighted average of these.
+
+##### Bug fixes
+ - Fixed error in HTML printer that was hiding concordance index information.
+
+
+#### 0.24.2 - 2020-03-15
+
+##### Bug fixes
+ - Fixed bug when no covariates were passed into `CoxPHFitter`. See #975
+ - Fixed error in `StatisticalResult` where the test name was not displayed correctly.
+ - Fixed a keyword bug in `plot_covariate_groups` for parametric models.
+
+
+#### 0.24.1 - 2020-03-05
+
+##### New features
+ - Stability improvements for GeneralizedGammaRegressionFitter and CoxPHFitter with spline estimation.
+
+##### Bug fixes
+ - Fixed bug with plotting hazards in NelsonAalenFitter.
+
+
+#### 0.24.0 - 2020-02-20
+
+This version and future versions of lifelines no longer support py35. Pandas 1.0 is fully supported, along with previous versions. Minimum Scipy has been bumped to 1.2.0.
+
+##### New features
+ - `CoxPHFitter` and `CoxTimeVaryingFitter` has support for an elastic net penalty, which includes L1 and L2 regression.
+ - `CoxPHFitter` has new baseline survival estimation methods. Specifically, `spline` now estimates the coefficients and baseline survival using splines. The traditional method, `breslow`, is still the default however.
+ - Regression models have a new `score` method that will score your model against a dataset (ex: a testing or validation dataset). The default is to evaluate the log-likelihood, but also the concordance index can be chose.
+ - New `MixtureCureFitter` for quickly creating univariate mixture models.
+ - Univariate parametric models have a `plot_density`, `density_at_times`, and property `density_` that computes the probability density function estimates.
+ - new dataset for interval regression involving *C. Botulinum*.
+ - new `lifelines.fitters.mixins.ProportionalHazardMixin` that implements proportional hazard checks.
+
+##### API Changes
+ - Models' prediction method that return a single array now return a Series (use to return a DataFrame). This includes `predict_median`, `predict_percentile`, `predict_expectation`, `predict_log_partial_hazard`, and possibly others.
+ - The penalty in Cox models is now scaled by the number of observations. This makes it invariant to changing sample sizes. This change also make the penalty magnitude behave the same as any parametric regression model.
+ - `score_` on models has been renamed `concordance_index_`
+ - models' `.variance_matrix_` is now a DataFrame.
+ - `CoxTimeVaryingFitter` no longer requires an `id_col`. It's optional, and some checks may be done for integrity if provided.
+ - Significant changes to `utils.k_fold_cross_validation`.
+ - removed automatically adding `inf` from `PiecewiseExponentialRegressionFitter.breakpoints` and `PiecewiseExponentialFitter.breakpoints`
+ - `tie_method` was dropped from Cox models (it was always Efron anyways...)
+ - Mixins are moved to `lifelines.fitters.mixins`
+ - `find_best_parametric_model` `evaluation` kwarg has been changed to `scoring_method`.
+ - removed `_score_` and `path` from Cox model.
+
+##### Bug fixes
+ - Fixed `show_censors` with `KaplanMeierFitter.plot_cumulative_density` see issue #940.
+ - Fixed error in `"BIC"` code path in `find_best_parametric_model`
+ - Fixed a bug where left censoring in AFT models was not converging well
+ - Cox models now incorporate any penalizers in their `log_likelihood_`
+
+
+#### 0.23.9 - 2020-01-28
+
+##### Bug fixes
+ - fixed important error when a parametric regression model would not assign the correct labels to fitted
+parameters' variances. See more here: https://github.com/CamDavidsonPilon/lifelines/issues/931. Users of `GeneralizedGammaRegressionFitter` and any custom regression models should update their code as soon as possible.
+
+#### 0.23.8 - 2020-01-21
+
+##### Bug fixes
+ - fixed important error when a parametric regression model would not assign the correct labels to fitted
+parameters. See more here: https://github.com/CamDavidsonPilon/lifelines/issues/931. Users of `GeneralizedGammaRegressionFitter` and any custom regression models should update their code as soon as possible.
+
+#### 0.23.7 - 2020-01-14
+
+Bug fixes for py3.5.
+
+#### 0.23.6 - 2020-01-07
+
+##### New features
+ - New univariate model, `SplineFitter`, that uses cubic splines to model the cumulative hazard.
+ - To aid users with selecting the best parametric model, there is a new `lifelines.utils.find_best_parametric_model` function that will iterate through the models and return the model with the lowest AIC (by default).
+ - custom parametric regression models can now do left and interval censoring.
+
+
+#### 0.23.5 - 2020-01-05
+
+##### New features
+ - New `predict_hazard` for parametric regression models.
+ - New lymph node cancer dataset, originally from *H.F. for the German Breast Cancer Study Group (GBSG) (1994)*
+
+##### Bug fixes
+ - fixes error thrown when converge of regression models fails.
+ - `kwargs` is now used in `plot_covariate_groups`
+ - fixed bug where large exponential numbers in `print_summary` were not being suppressed correctly.
+
+#### 0.23.4 - 2019-12-15
+
+ - Bug fix for PyPI
+
+#### 0.23.3 - 2019-12-11
+
+##### New features
+ - `StatisticalResult.print_summary` supports html output.
+
+##### Bug fixes
+ - fix import in `printer.py`
+ - fix html printing with Univariate models.
+
+
+#### 0.23.2 - 2019-12-07
+
+##### New features
+ - new `lifelines.plotting.rmst_plot` for pretty figures of survival curves and RMSTs.
+ - new variance calculations for `lifelines.utils.resticted_mean_survival_time`
+ - performance improvements on regression models' preprocessing. Should make datasets with
+ high number of columns more performant.
+
+##### Bug fixes
+ - fixed `print_summary` for AAF class.
+ - fixed repr for `sklearn_adapter` classes.
+ - fixed `conditional_after` in Cox model with strata was used.
+
+
+#### 0.23.1 - 2019-11-27
+
+##### New features
+ - new `print_summary` option `style` to print HTML, LaTeX or ASCII output
+ - performance improvements for `CoxPHFitter` - up to 30% performance improvements for some datasets.
+
+##### Bug fixes
+ - fixed bug where computed statistics were not being shown in `print_summary` for HTML output.
+ - fixed bug where "None" was displayed in models' `__repr__`
+ - fixed bug in `StatisticalResult.print_summary`
+ - fixed bug when using `print_summary` with left censored models.
+ - lots of minor bug fixes.
+
+#### 0.23.0 - 2019-11-17
+
+##### New features
+ - new `print_summary` abstraction that allows HTML printing in Jupyter notebooks!
+ - silenced some warnings.
+
+##### Bug fixes
+ - The "comparison" value of some parametric univariate models wasn't standard, so the null hypothesis p-value may have been wrong. This is now fixed.
+ - fixed a NaN error in confidence intervals for KaplanMeierFitter
+
+##### API Changes
+
+ - To align values across models, the column names for the confidence intervals in parametric univariate models `summary` have changed.
+ - Fixed typo in `ParametricUnivariateFitter` name.
+ - `median_` has been removed in favour of `median_survival_time_`.
+ - `left_censorship` in `fit` has been removed in favour of `fit_left_censoring`.
+
+
+#### 0.22.10 - 2019-11-08
+
+The tests were re-factored to be shipped with the package. Let me know if this causes problems.
+
+
+##### Bug fixes
+ - fixed error in plotting models with "lower" or "upper" was in the label name.
+ - fixed bug in plot_covariate_groups for AFT models when >1d arrays were used for values arg.
+
+
+#### 0.22.9 - 2019-10-30
+
+
+##### Bug fixes
+ - fixed `predict_` methods in AFT models when `timeline` was not specified.
+ - fixed error in `qq_plot`
+ - fixed error when submitting a model in `qth_survival_time`
+ - `CoxPHFitter` now displays correct columns values when changing alpha param.
+
+
+#### 0.22.8 - 2019-10-06
+
+##### New features
+ - Serializing lifelines is better supported. Packages like joblib and pickle are now supported. Thanks @AbdealiJK!
+ - `conditional_after` now available in `CoxPHFitter.predict_median`
+ - Suppressed some unimportant warnings.
+
+##### Bug fixes
+ - fixed initial_point being ignored in AFT models.
+
+
+#### 0.22.7 - 2019-09-29
+
+##### New features
+ - new `ApproximationWarning` to tell you if the package is making an potentially mislead approximation.
+
+##### Bug fixes
+ - fixed a bug in parametric prediction for interval censored data.
+ - realigned values in `print_summary`.
+ - fixed bug in `survival_difference_at_fixed_point_in_time_test`
+
+##### API Changes
+
+ - `utils.qth_survival_time` no longer takes a `cdf` argument - users should take the compliment (1-cdf).
+ - Some previous `StatisticalWarnings` have been replaced by `ApproximationWarning`
+
+#### 0.22.6 - 2019-09-25
+
+##### New features
+ - `conditional_after` works for `CoxPHFitter` prediction models 😅
+
+##### Bug fixes
+
+##### API Changes
+ - `CoxPHFitter.baseline_cumulative_hazard_`'s column is renamed `"baseline cumulative hazard"` - previously it was `"baseline hazard"`. (Only applies if the model has no strata.)
+ - `utils.dataframe_interpolate_at_times` renamed to `utils.interpolate_at_times_and_return_pandas`.
+
+
+#### 0.22.5 - 2019-09-20
+
+##### New features
+ - Improvements to the __repr__ of models that takes into accounts weights.
+ - Better support for predicting on Pandas Series
+
+##### Bug fixes
+ - Fixed issue where `fit_interval_censoring` wouldn't accept lists.
+ - Fixed an issue with `AalenJohansenFitter` failing to plot confidence intervals.
+
+##### API Changes
+ - `_get_initial_value` in parametric univariate models is renamed `_create_initial_point`
+
+
+#### 0.22.4 - 2019-09-04
+
+##### New features
+ - Some performance improvements to regression models.
+ - lifelines will avoid penalizing the intercept (aka bias) variables in regression models.
+ - new `utils.restricted_mean_survival_time` that approximates the RMST using numerical integration against survival functions.
+
+##### API changes
+ - `KaplanMeierFitter.survival_function_`'s' index is no longer given the name "timeline".
+
+##### Bug fixes
+ - Fixed issue where `concordance_index` would never exit if NaNs in dataset.
+
+
+#### 0.22.3 - 2019-08-08
+
+##### New features
+ - model's now expose a `log_likelihood_` property.
+ - new `conditional_after` argument on `predict_*` methods that make prediction on censored subjects easier.
+ - new `lifelines.utils.safe_exp` to make `exp` overflows easier to handle.
+ - smarter initial conditions for parametric regression models.
+ - New regression model: `GeneralizedGammaRegressionFitter`
+
+##### API changes
+ - removed `lifelines.utils.gamma` - use `autograd_gamma` library instead.
+ - removed bottleneck as a dependency. It offered slight performance gains only in Cox models, and only a small fraction of the API was being used.
+
+##### Bug fixes
+ - AFT log-likelihood ratio test was not using weights correctly.
+ - corrected (by bumping) scipy and autograd dependencies
+ - convergence is improved for most models, and many `exp` overflow warnings have been eliminated.
+ - Fixed an error in the `predict_percentile` of `LogLogisticAFTFitter`. New tests have been added around this.
+
+
+#### 0.22.2 - 2019-07-25
+
+##### New features
+ - lifelines is now compatible with scipy>=1.3.0
+
+##### Bug fixes
+ - fixed printing error when using robust=True in regression models
+ - `GeneralizedGammaFitter` is more stable, maybe.
+ - lifelines was allowing old version of numpy (1.6), but this caused errors when using the library. The correctly numpy has been pinned (to 1.14.0+)
+
+
+
+#### 0.22.1 - 2019-07-14
+
+##### New features
+ - New univariate model, `GeneralizedGammaFitter`. This model contains many sub-models, so it is a good model to check fits.
+ - added a warning when a time-varying dataset had instantaneous deaths.
+ - added a `initial_point` option in univariate parametric fitters.
+ - `initial_point` kwarg is present in parametric univariate fitters `.fit`
+ - `event_table` is now an attribute on all univariate fitters (if right censoring)
+ - improvements to `lifelines.utils.gamma`
+
+##### API changes
+ - In AFT models, the column names in `confidence_intervals_` has changed to include the alpha value.
+ - In AFT models, some column names in `.summary` and `.print_summary` has changed to include the alpha value.
+ - In AFT models, some column names in `.summary` and `.print_summary` includes confidence intervals for the exponential of the value.
+
+##### Bug fixes
+ - when using `censors_show` in plotting functions, the censor ticks are now reactive to the estimate being shown.
+ - fixed an overflow bug in `KaplanMeierFitter` confidence intervals
+ - improvements in data validation for `CoxTimeVaryingFitter`
+
+
+#### 0.22.0 - 2019-07-03
+
+##### New features
+ - Ability to create custom parametric regression models by specifying the cumulative hazard. This enables new and extensions of AFT models.
+ - `percentile(p)` method added to univariate models that solves the equation `p = S(t)` for `t`
+ - for parametric univariate models, the `conditional_time_to_event_` is now exact instead of an approximation.
+
+##### API changes
+ - In Cox models, the attribute `hazards_` has been renamed to `params_`. This aligns better with the other regression models, and is more clear (what is a hazard anyways?)
+ - In Cox models, a new `hazard_ratios_` attribute is available which is the exponentiation of `params_`.
+ - In Cox models, the column names in `confidence_intervals_` has changed to include the alpha value.
+ - In Cox models, some column names in `.summary` and `.print_summary` has changed to include the alpha value.
+ - In Cox models, some column names in `.summary` and `.print_summary` includes confidence intervals for the exponential of the value.
+ - Significant changes to internal AFT code.
+ - A change to how `fit_intercept` works in AFT models. Previously one could set `fit_intercept` to False and not have to set `ancillary_df` - now one must specify a DataFrame.
+
+##### Bug fixes
+ - for parametric univariate models, the `conditional_time_to_event_` is now exact instead of an approximation.
+ - fixed a name error bug in `CoxTimeVaryingFitter.plot`
+
+#### 0.21.5 - 2019-06-22
+
+I'm skipping 0.21.4 version because of deployment issues.
+
+##### New features
+ - `scoring_method` now a kwarg on `sklearn_adapter`
+
+##### Bug fixes
+ - fixed an implicit import of scikit-learn. scikit-learn is an optional package.
+ - fixed visual bug that misaligned x-axis ticks and at-risk counts. Thanks @christopherahern!
+
+
+#### 0.21.3 - 2019-06-04
+
+##### New features
+ - include in lifelines is a scikit-learn adapter so lifeline's models can be used with scikit-learn's API. See [documentation here](https://lifelines.readthedocs.io/en/latest/Compatibility%20with%20scikit-learn.html).
+ - `CoxPHFitter.plot` now accepts a `hazard_ratios` (boolean) parameter that will plot the hazard ratios (and CIs) instead of the log-hazard ratios.
+ - `CoxPHFitter.check_assumptions` now accepts a `columns` parameter to specify only checking a subset of columns.
+
+##### Bug fixes
+ - `covariates_from_event_matrix` handle nulls better
+
+
+#### 0.21.2 - 2019-05-16
+
+##### New features
+ - New regression model: `PiecewiseExponentialRegressionFitter` is available. See blog post here: https://dataorigami.net/blogs/napkin-folding/churn
+ - Regression models have a new method `log_likelihood_ratio_test` that computes, you guessed it, the log-likelihood ratio test. Previously this was an internal API that is being exposed.
+
+##### API changes
+ - The default behavior of the `predict` method on non-parametric estimators (`KaplanMeierFitter`, etc.) has changed from (previous) linear interpolation to (new) return last value. Linear interpolation is still possible with the `interpolate` flag.
+ - removing `_compute_likelihood_ratio_test` on regression models. Use `log_likelihood_ratio_test` now.
+
+##### Bug fixes
+
+
+#### 0.21.1 - 2019-04-26
+
+##### New features
+ - users can provided their own start and stop column names in `add_covariate_to_timeline`
+ - PiecewiseExponentialFitter now allows numpy arrays as breakpoints
+
+##### API changes
+ - output of `survival_table_from_events` when collapsing rows to intervals now removes the "aggregate" column multi-index.
+
+##### Bug fixes
+ - fixed bug in CoxTimeVaryingFitter when ax is provided, thanks @j-i-l!
+
+#### 0.21.0 - 2019-04-12
+
+##### New features
+ - `weights` is now a optional kwarg for parametric univariate models.
+ - all univariate and multivariate parametric models now have ability to handle left, right and interval censored data (the former two being special cases of the latter). Users can use the `fit_right_censoring` (which is an alias for `fit`), `fit_left_censoring` and `fit_interval_censoring`.
+ - a new interval censored dataset is available under `lifelines.datasets.load_diabetes`
+
+##### API changes
+ - `left_censorship` on all univariate fitters has been deprecated. Please use the new
+ api `model.fit_left_censoring(...)`.
+ - `invert_y_axis` in `model.plot(...` has been removed.
+ - `entries` property in multivariate parametric models has a new Series name: `entry`
+
+##### Bug fixes
+ - lifelines was silently converting any NaNs in the event vector to True. An error is now thrown instead.
+ - Fixed an error that didn't let users use Numpy arrays in prediction for AFT models
+
+
+#### 0.20.5 - 2019-04-08
+
+##### New features
+ - performance improvements for `print_summary`.
+
+##### API changes
+ - `utils.survival_events_from_table` returns an integer weight vector as well as durations and censoring vector.
+ - in `AalenJohansenFitter`, the `variance` parameter is renamed to `variance_` to align with the usual lifelines convention.
+
+##### Bug fixes
+ - Fixed an error in the `CoxTimeVaryingFitter`'s likelihood ratio test when using strata.
+ - Fixed some plotting bugs with `AalenJohansenFitter`
+
+
+#### 0.20.4 - 2019-03-27
+
+##### New features
+ - left-truncation support in AFT models, using the `entry_col` kwarg in `fit()`
+ - `generate_datasets.piecewise_exponential_survival_data` for generating piecewise exp. data
+ - Faster `print_summary` for AFT models.
+
+##### API changes
+ - Pandas is now correctly pinned to >= 0.23.0. This was always the case, but not specified in setup.py correctly.
+
+##### Bug fixes
+ - Better handling for extremely large numbers in `print_summary`
+ - `PiecewiseExponentialFitter` is available with `from lifelines import *`.
+
+
+#### 0.20.3 - 2019-03-23
+
+##### New features
+ - Now `cumulative_density_` & `survival_function_` are _always_ present on a fitted `KaplanMeierFitter`.
+ - New attributes/methods on `KaplanMeierFitter`: `plot_cumulative_density()`, `confidence_interval_cumulative_density_`, `plot_survival_function` and `confidence_interval_survival_function_`.
+
+
+#### 0.20.2 - 2019-03-21
+
+##### New features
+ - Left censoring is now supported in univariate parametric models: `.fit(..., left_censorship=True)`. Examples are in the docs.
+ - new dataset: `lifelines.datasets.load_nh4()`
+ - Univariate parametric models now include, by default, support for the cumulative density function: `.cumulative_density_`, `.confidence_interval_cumulative_density_`, `plot_cumulative_density()`, `cumulative_density_at_times(t)`.
+ -  add a `lifelines.plotting.qq_plot` for univariate parametric models that handles censored data.
+
+##### API changes
+ - `plot_lifetimes` no longer reverses the order when plotting. Thanks @vpolimenov!
+ - The `C` column in `load_lcd` dataset is renamed to `E`.
+
+##### Bug fixes
+ - fixed a naming error in `KaplanMeierFitter` when `left_censorship` was set to True, `plot_cumulative_density_()` is now `plot_cumulative_density()`.
+ - added some error handling when passing in timedeltas. Ideally, users don't pass in timedeltas, as the scale is ambiguous. However, the error message before was not obvious, so we do some conversion, warn the user, and pass it through.
+ - `qth_survival_times` for a truncated CDF would return `np.inf` if the q parameter was below the truncation limit. This should have been `-np.inf`
+
+
+#### 0.20.1 - 2019-03-16
+
+ - Some performance improvements to `CoxPHFitter` (about 30%). I know it may seem silly, but we are now about the same or slighty faster than the Cox model in R's `survival` package (for some testing datasets and some configurations). This is a big deal, because 1) lifelines does more error checking prior, 2) R's cox model is written in C, and we are still pure Python/NumPy, 3) R's cox model has decades of development.
+ - suppressed unimportant warnings
+
+##### API changes
+ - Previously, lifelines _always_ added a 0 row to `cph.baseline_hazard_`, even if there were no event at this time. This is no longer the case. A 0 will still be added if there is a duration (observed or not) at 0 occurs however.
+
+
+#### 0.20.0 - 2019-03-05
+
+ - Starting with 0.20.0, only Python3 will be supported. Over 75% of recent installs where Py3.
+ - Updated minimum dependencies, specifically Matplotlib and Pandas.
+
+##### New features
+ -  smarter initialization for AFT models which should improve convergence.
+
+##### API changes
+ - `inital_beta` in Cox model's `.fit` is now `initial_point`.
+ - `initial_point` is now available in AFT models and `CoxTimeVaryingFitter`
+ - the DataFrame `confidence_intervals_` for univariate models is transposed now (previous parameters where columns, now parameters are rows).
+
+##### Bug fixes
+ - Fixed a bug with plotting and `check_assumptions`.
+
+
+
+#### 0.19.5 - 2019-02-26
+
+##### New features
+ -  `plot_covariate_group` can accept multiple covariates to plot. This is useful for columns that have implicit correlation like polynomial features or categorical variables.
+ - Convergence improvements for AFT models.
+
+#### 0.19.4 - 2019-02-25
+
+##### Bug fixes
+ - remove some bad print statements in `CoxPHFitter`.
+
+#### 0.19.3 - 2019-02-25
+
+##### New features
+ - new AFT models: `LogNormalAFTFitter` and `LogLogisticAFTFitter`.
+ - AFT models now accept a `weights_col` argument to `fit`.
+ - Robust errors (sandwich errors) are now avilable in AFT models using the `robust=True` kwarg in `fit`.
+ - Performance increase to `print_summary` in the `CoxPHFitter` and `CoxTimeVaryingFitter` model.
+
+#### 0.19.2 - 2019-02-22
+
+##### New features
+ - `ParametricUnivariateFitters`, like `WeibullFitter`, have smoothed plots when plotting (vs stepped plots)
+
+##### Bug fixes
+ - The `ExponentialFitter` log likelihood _value_ was incorrect - inference was correct however.
+ - Univariate fitters are more flexiable and can allow 2-d and DataFrames as inputs.
+
+#### 0.19.1 - 2019-02-21
+
+##### New features
+ - improved stability of `LogNormalFitter`
+ - Matplotlib for Python3 users are not longer forced to use 2.x.
+
+##### API changes
+ - **Important**: we changed the parameterization of the `PiecewiseExponential` to the same as `ExponentialFitter` (from `\lambda * t` to `t / \lambda`).
+
+
+#### 0.19.0 - 2019-02-20
+
+##### New features
+ - New regression model `WeibullAFTFitter` for fitting accelerated failure time models. Docs have been added to our [documentation](https://lifelines.readthedocs.io/) about how to use `WeibullAFTFitter` (spoiler: it's API is similar to the other regression models) and how to interpret the output.
+ - `CoxPHFitter` performance improvements (about 10%)
+ - `CoxTimeVaryingFitter` performance improvements (about 10%)
+
+
+##### API changes
+ - **Important**: we changed the `.hazards_` and `.standard_errors_` on Cox models to be pandas Series (instead of Dataframes). This felt like a more natural representation of them. You may need to update your code to reflect this. See notes here: https://github.com/CamDavidsonPilon/lifelines/issues/636
+ - **Important**: we changed the `.confidence_intervals_` on Cox models to be transposed. This felt like a more natural representation of them. You may need to update your code to reflect this. See notes here: https://github.com/CamDavidsonPilon/lifelines/issues/636
+ - **Important**: we changed the parameterization of the `WeibullFitter` and `ExponentialFitter` from `\lambda * t` to `t / \lambda`. This was for a few reasons: 1) it is a more common parameterization in literature, 2) it helps in convergence.
+ - **Important**: in models where we add an intercept (currently only `AalenAdditiveModel`), the name of the added column has been changed from `baseline` to `_intercept`
+ - **Important**: the meaning of `alpha` in all fitters has changed to be the standard interpretation of alpha in confidence intervals. That means that the _default_ for alpha is set to 0.05 in the latest lifelines, instead of 0.95 in previous versions.
+
+##### Bug Fixes
+ - Fixed a bug in the `_log_likelihood_` property of `ParametericUnivariateFitter` models. It was showing the "average" log-likelihood (i.e. scaled by 1/n) instead of the total. It now displays the total.
+ - In model `print_summary`s, correct a label erroring. Instead of "Likelihood test", it should have read "Log-likelihood test".
+ - Fixed a bug that was too frequently rejecting the dtype of `event` columns.
+ - Fixed a calculation bug in the concordance index for stratified Cox models. Thanks @airanmehr!
+ - Fixed some Pandas <0.24 bugs.
+
+#### 0.18.6 - 2019-02-13
+
+ - some improvements to the output of `check_assumptions`. `show_plots` is turned to `False` by default now. It only shows `rank` and `km` p-values now.
+ - some performance improvements to `qth_survival_time`.
+
+#### 0.18.5 - 2019-02-11
+
+ - added new plotting methods to parametric univariate models: `plot_survival_function`, `plot_hazard` and `plot_cumulative_hazard`. The last one is an alias for `plot`.
+ - added new properties to parametric univarite models: `confidence_interval_survival_function_`, `confidence_interval_hazard_`, `confidence_interval_cumulative_hazard_`. The last one is an alias for `confidence_interval_`.
+ - Fixed some overflow issues with `AalenJohansenFitter`'s variance calculations when using large datasets.
+ - Fixed an edgecase in `AalenJohansenFitter` that causing some datasets with to be jittered too often.
+ - Add a new kwarg to  `AalenJohansenFitter`, `calculate_variance` that can be used to turn off variance calculations since this can take a long time for large datasets. Thanks @pzivich!
+
+#### 0.18.4 - 2019-02-10
+
+ - fixed confidence intervals in cumulative hazards for parametric univarite models. They were previously
+   serverly depressed.
+ - adding left-truncation support to parametric univarite models with the `entry` kwarg in `.fit`
+
+#### 0.18.3 - 2019-02-07
+
+ - Some performance improvements to parametric univariate models.
+ - Suppressing some irrelevant NumPy and autograd warnings, so lifeline warnings are more noticeable.
+ - Improved some warning and error messages.
+
+#### 0.18.2 - 2019-02-05
+
+ - New univariate fitter `PiecewiseExponentialFitter` for creating a stepwise hazard model. See docs online.
+ - Ability to create novel parametric univariate models using the new `ParametericUnivariateFitter` super class. See docs online for how to do this.
+ - Unfortunately, parametric univariate fitters are not serializable with `pickle`. The library `dill` is still useable.
+ - Complete overhaul of all internals for parametric univariate fitters. Moved them all (most) to use `autograd`.
+ - `LogNormalFitter` no longer models `log_sigma`.
+
+
+#### 0.18.1 - 2019-02-02
+ - bug fixes in `LogNormalFitter` variance estimates
+ - improve convergence of `LogNormalFitter`. We now model the log of sigma internally, but still expose sigma externally.
+ - use the `autograd` lib to help with gradients.
+ - New `LogLogisticFitter` univariate fitter available.
+
+#### 0.18.0 - 2019-01-31
+
+ - `LogNormalFitter` is a new univariate fitter you can use.
+ - `WeibullFitter` now correctly returns the confidence intervals (previously returned only NaNs)
+ - `WeibullFitter.print_summary()` displays p-values associated with its parameters not equal to 1.0 - previously this was (implicitly) comparing against 0, which is trivially always true (the parameters must be greater than 0)
+ - `ExponentialFitter.print_summary()` displays p-values associated with its parameters not equal to 1.0 - previously this was (implicitly) comparing against 0, which is trivially always true (the parameters must be greater than 0)
+ - `ExponentialFitter.plot` now displays the cumulative hazard, instead of the survival function. This is to make it easier to compare to `WeibullFitter` and `LogNormalFitter`
+ - Univariate fitters' `cumulative_hazard_at_times`, `hazard_at_times`, `survival_function_at_times` return pandas Series now (use to be numpy arrays)
+ - remove `alpha` keyword from all statistical functions. This was never being used.
+ - Gone are astericks and dots in `print_summary` functions that represent signficance thresholds.
+ - In models' `summary` (including `print_summary`), the `log(p)` term has changed to `-log2(p)`. This is known as the s-value. See https://lesslikely.com/statistics/s-values/
+ - introduce new statistical tests between univariate datasets: `survival_difference_at_fixed_point_in_time_test`,...
+ - new warning message when Cox models detects possible non-unique solutions to maximum likelihood.
+ - Generally: clean up lifelines exception handling. Ex: catch `LinAlgError: Matrix is singular.` and report back to the user advice.
+
+#### 0.17.5 - 2019-01-25
+
+ - more bugs in `plot_covariate_groups` fixed when using non-numeric strata.
+
+#### 0.17.4 -2019-01-25
+
+ - Fix bug in `plot_covariate_groups` that wasn't allowing for strata to be used.
+ - change name of `multicenter_aids_cohort_study` to `load_multicenter_aids_cohort_study`
+ - `groups` is now called `values` in `CoxPHFitter.plot_covariate_groups`
+
+#### 0.17.3 - 2019-01-24
+ - Fix in `compute_residuals` when using `schoenfeld` and the minumum duration has only censored subjects.
+
+#### 0.17.2 2019-01-22
+ - Another round of serious performance improvements for the Cox models. Up to 2x faster for CoxPHFitter and CoxTimeVaryingFitter. This was mostly the result of using NumPy's `einsum` to simplify a previous `for` loop. The downside is the code is more esoteric now. I've added comments as necessary though 🤞
+
+#### 0.17.1 - 2019-01-20
+
+ - adding bottleneck as a dependency. This library is highly-recommended by Pandas, and in lifelines we see some nice performance improvements with it too. (~15% for `CoxPHFitter`)
+ - There was a small bug in `CoxPHFitter` when using `batch_mode` that was causing coefficients to deviate from their MLE value. This bug eluded tests, which means that it's discrepancy was less than 0.0001 difference. It's fixed now, and even more accurate tests are added.
+ - Faster `CoxPHFitter._compute_likelihood_ratio_test()`
+ - Fixes a Pandas performance warning in `CoxTimeVaryingFitter`.
+ - Performances improvements to `CoxTimeVaryingFitter`.
+
+#### 0.17.0 - 2019-01-11
+
+ - corrected behaviour in `CoxPHFitter` where `score_` was not being refreshed on every new `fit`.
+ - Reimplentation of `AalenAdditiveFitter`. There were significant changes to it:
+   - implementation is at least 10x faster, and possibly up to 100x faster for some datasets.
+   - memory consumption is way down
+   - removed the time-varying component from `AalenAdditiveFitter`. This will return in a future release.
+   - new `print_summary`
+   - `weights_col` is added
+   - `nn_cumulative_hazard` is removed (may add back)
+ - some plotting improvemnts to `plotting.plot_lifetimes`
+
+
+#### 0.16.3 - 2019-01-03
+
+ - More `CoxPHFitter` performance improvements. Up to a 40% reduction vs 0.16.2 for some datasets.
+
+#### 0.16.2 - 2019-01-02
+
+ - Fixed `CoxTimeVaryingFitter` to allow more than one variable to be stratafied
+ - Significant performance improvements for `CoxPHFitter` with dataset has lots of duplicate times. See https://github.com/CamDavidsonPilon/lifelines/issues/591
+
+#### 0.16.1 - 2019-01-01
+ - Fixed py2 division error in `concordance` method.
+
+#### 0.16.0 - 2019-01-01
+
+ - Drop Python 3.4 support.
+ - introduction of residual calculations in `CoxPHFitter.compute_residuals`. Residuals include "schoenfeld", "score", "delta_beta", "deviance", "martingale", and "scaled_schoenfeld".
+ - removes `estimation` namespace for fitters. Should be using `from lifelines import xFitter` now. Thanks @usmanatron
+ - removes `predict_log_hazard_relative_to_mean` from Cox model. Thanks @usmanatron
+ - `StatisticalResult` has be generalized to allow for multiple results (ex: from pairwise comparisons). This means a slightly changed API that is mostly backwards compatible. See doc string for how to use it.
+ - `statistics.pairwise_logrank_test` now returns a `StatisticalResult` object instead of a nasty NxN DataFrame 💗
+ - Display log(p-values) as well as p-values in `print_summary`. Also, p-values below thesholds will be truncated. The orignal p-values are still recoverable using `.summary`.
+ - Floats `print_summary` is now displayed to 2 decimal points. This can be changed using the `decimal` kwarg.
+ - removed `standardized` from `Cox` model plotting. It was confusing.
+ - visual improvements to Cox models `.plot`
+ - `print_summary` methods accepts kwargs to also be displayed.
+ - `CoxPHFitter` has a new human-readable method, `check_assumptions`, to check the assumptions of your Cox proportional hazard model.
+ - A new helper util to "expand" static datasets into long-form: `lifelines.utils.to_episodic_format`.
+ - `CoxTimeVaryingFitter` now accepts `strata`.
+
+#### 0.15.4
+
+ - bug fix for the Cox model likelihood ratio test when using non-trivial weights.
+
+#### 0.15.3 - 2018-12-18
+ - Only allow matplotlib less than 3.0.
+
+#### 0.15.2 - 2018-11-23
+ - API changes to `plotting.plot_lifetimes`
+ - `cluster_col` and `strata` can be used together in `CoxPHFitter`
+ - removed `entry` from `ExponentialFitter` and `WeibullFitter` as it was doing nothing.
+
+#### 0.15.1 - 2018-11-23
+ - Bug fixes for v0.15.0
+ - Raise NotImplementedError if the `robust` flag is used in `CoxTimeVaryingFitter` - that's not ready yet.
+
+#### 0.15.0 - 2018-11-22
+ - adding `robust` params to `CoxPHFitter`'s `fit`. This enables atleast i) using non-integer weights in the model (these could be sampling weights like IPTW), and ii) mis-specified models (ex: non-proportional hazards). Under the hood it's a sandwich estimator. This does not handle ties, so if there are high number of ties, results may significantly differ from other software.
+ - `standard_errors_` is now a property on fitted `CoxPHFitter` which describes the standard errors of the coefficients.
+ - `variance_matrix_` is now a property on fitted `CoxPHFitter` which describes the variance matrix of the coefficients.
+ - new criteria for convergence of `CoxPHFitter` and `CoxTimeVaryingFitter` called the Newton-decrement. Tests show it is as accurate (w.r.t to previous coefficients) and typically shaves off a single step, resulting in generally faster convergence. See https://www.cs.cmu.edu/~pradeepr/convexopt/Lecture_Slides/Newton_methods.pdf. Details about the Newton-decrement are added to the `show_progress` statements.
+ - Minimum suppport for scipy is 1.0
+ - Convergence errors in models that use Newton-Rhapson methods now throw a `ConvergenceError`, instead of a `ValueError` (the former is a subclass of the latter, however).
+ - `AalenAdditiveModel` raises `ConvergenceWarning` instead of printing a warning.
+ - `KaplanMeierFitter` now has a cumulative plot option. Example `kmf.plot(invert_y_axis=True)`
+ - a `weights_col` option has been added to `CoxTimeVaryingFitter` that allows for time-varying weights.
+ - `WeibullFitter` has a new `show_progress` param and additional information if the convergence fails.
+ - `CoxPHFitter`, `ExponentialFitter`, `WeibullFitter` and `CoxTimeVaryFitter` method `print_summary` is updated with new fields.
+ - `WeibullFitter` has renamed the incorrect `_jacobian` to `_hessian_`.
+ - `variance_matrix_` is now a property on fitted `WeibullFitter` which describes the variance matrix of the parameters.
+ - The default `WeibullFitter().timeline` has changed from integers between the min and max duration to _n_ floats between the max and min durations, where _n_ is the number of observations.
+ - Performance improvements for `CoxPHFitter` (~20% faster)
+ - Performance improvements for `CoxTimeVaryingFitter` (~100% faster)
+ - In Python3, Univariate models are now serialisable with `pickle`. Thanks @dwilson1988 for the contribution. For Python2, `dill` is still the preferred method.
+ - `baseline_cumulative_hazard_` (and derivatives of that) on `CoxPHFitter` now correctly incorporate the `weights_col`.
+ - Fixed a bug in `KaplanMeierFitter` when late entry times lined up with death events. Thanks @pzivich
+ - Adding `cluster_col` argument to `CoxPHFitter` so users can specify groups of subjects/rows that may be correlated.
+ - Shifting the "signficance codes" for p-values down an order of magnitude. (Example, p-values between 0.1 and 0.05 are not noted at all and p-values between 0.05 and 0.1 are noted with `.`, etc.). This deviates with how they are presented in other software. There is an argument to be made to remove p-values from lifelines altogether (_become the changes you want to see in the world_ lol), but I worry that people could compute the p-values by hand incorrectly, a worse outcome I think. So, this is my stance. P-values between 0.1 and 0.05 offer _very_ little information, so they are removed. There is a growing movement in statistics to shift "signficant" findings to p-values less than 0.01 anyways.
+ - New fitter for cumulative incidence of multiple risks `AalenJohansenFitter`. Thanks @pzivich! See "Methodologic Issues When Estimating Risks in Pharmacoepidemiology" for a nice overview of the model.
+
+#### 0.14.6 - 2018-07-02
+ - fix for n > 2 groups in `multivariate_logrank_test` (again).
+ - fix bug for when `event_observed` column was not boolean.
+
+#### 0.14.5 - 2018-06-29
+ - fix for n > 2 groups in `multivariate_logrank_test`
+ - fix weights in KaplanMeierFitter when using a pandas Series.
+
+#### 0.14.4 - 2018-06-14
+ - Adds `baseline_cumulative_hazard_` and `baseline_survival_` to `CoxTimeVaryingFitter`. Because of this, new prediction methods are available.
+ - fixed a bug in `add_covariate_to_timeline` when using `cumulative_sum` with multiple columns.
+ - Added `Likelihood ratio test` to `CoxPHFitter.print_summary` and `CoxTimeVaryingFitter.print_summary`
+ - New checks in `CoxTimeVaryingFitter` that check for immediate deaths and redundant rows.
+ - New `delay` parameter in `add_covariate_to_timeline`
+ - removed `two_sided_z_test` from `statistics`
+
+#### 0.14.3 - 2018-05-24
+ - fixes a bug when subtracting or dividing two `UnivariateFitters` with labels.
+ - fixes an import error with using `CoxTimeVaryingFitter` predict methods.
+ - adds a `column` argument to `CoxTimeVaryingFitter` and `CoxPHFitter` `plot` method to plot only a subset of columns.
+
+#### 0.14.2 - 2018-05-18
+ - some quality of life improvements for working with `CoxTimeVaryingFitter` including new `predict_` methods.
+
+#### 0.14.1 - 2018-04-01
+ - fixed bug with using weights and strata in `CoxPHFitter`
+ - fixed bug in using non-integer weights in `KaplanMeierFitter`
+ - Performance optimizations in `CoxPHFitter` for up to 40% faster completion of `fit`.
+    - even smarter `step_size` calculations for iterative optimizations.
+    - simple code optimizations & cleanup in specific hot spots.
+ - Performance optimizations in `AalenAdditiveFitter` for up to 50% faster completion of `fit` for large dataframes, and up to 10% faster for small dataframes.
+
+
+#### 0.14.0 - 2018-03-03
+ - adding `plot_covariate_groups` to `CoxPHFitter` to visualize what happens to survival as we vary a covariate, all else being equal.
+ - `utils` functions like `qth_survival_times` and `median_survival_times` now return the transpose of the DataFrame compared to previous version of lifelines. The reason for this is that we often treat survival curves as columns in DataFrames, and functions of the survival curve as index (ex: KaplanMeierFitter.survival_function_ returns a survival curve _at_ time _t_).
+ - `KaplanMeierFitter.fit` and `NelsonAalenFitter.fit` accept a `weights` vector that can be used for pre-aggregated datasets. See this [issue](https://github.com/CamDavidsonPilon/lifelines/issues/396).
+ - Convergence errors now return a custom `ConvergenceWarning` instead of a `RuntimeWarning`
+ - New checks for complete separation in the dataset for regressions.
+
+#### 0.13.0 - 2017-12-22
+ - removes `is_significant` and `test_result` from `StatisticalResult`. Users can instead choose their significance level by comparing to `p_value`. The string representation of this class has changed aswell.
+ - `CoxPHFitter` and `AalenAdditiveFitter` now have a `score_` property that is the concordance-index of the dataset to the fitted model.
+ - `CoxPHFitter` and `AalenAdditiveFitter` no longer have the `data` property. It was an _almost_ duplicate of the training data, but was causing the model to be very large when serialized.
+ - Implements a new fitter `CoxTimeVaryingFitter` available under the `lifelines` namespace. This model implements the Cox model for time-varying covariates.
+ - Utils for creating time varying datasets available in `utils`.
+ - less noisy check for complete separation.
+ - removed `datasets` namespace from the main `lifelines` namespace
+ - `CoxPHFitter` has a slightly more intelligent (barely...) way to pick a step size, so convergence should generally be faster.
+ - `CoxPHFitter.fit` now has accepts a `weight_col` kwarg so one can pass in weights per observation. This is very useful if you have many subjects, and the space of covariates is not large. Thus you can group the same subjects together and give that observation a weight equal to the count. Altogether, this means a much faster regression.
+
+#### 0.12.0
+ - removes  `include_likelihood` from `CoxPHFitter.fit` - it was not slowing things down much (empirically), and often I wanted it for debugging (I suppose others do too). It's also another exit condition, so we many exit from the NR iterations faster.
+ - added `step_size` param to `CoxPHFitter.fit` - the default is good, but for extremely large or small datasets this may want to be set manually.
+ - added a warning to `CoxPHFitter` to check for complete seperation: https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/
+ - Additional functionality to `utils.survival_table_from_events` to bin the index to make the resulting table more readable.
+
+#### 0.11.3
+ - No longer support matplotlib 1.X
+ - Adding `times` argument to `CoxPHFitter`'s `predict_survival_function` and `predict_cumulative_hazard` to predict the estimates at, instead uses the default times of observation or censorship.
+ - More accurate prediction methods parametrics univariate models.
+
+#### 0.11.2
+ - Changing liscense to valilla MIT.
+ - Speed up `NelsonAalenFitter.fit` considerably.
+
+#### 0.11.1 - 2017-06-22
+ - Python3 fix for `CoxPHFitter.plot`.
+
+#### 0.11.0 - 2017-06-21
+ - fixes regression in `KaplanMeierFitter.plot` when using Seaborn and lifelines.
+ - introduce a new `.plot` function to a fitted `CoxPHFitter` instance. This plots the hazard coefficients and their confidence intervals.
+ - in all plot methods, the `ix` kwarg has been deprecated in favour of a new `loc` kwarg. This is to align with Pandas deprecating `ix`
+
+#### 0.10.1 - 2017-06-05
+ - fix in internal normalization for `CoxPHFitter` predict methods.
+
+#### 0.10.0
+ - corrected bug that was returning the wrong baseline survival and hazard values in `CoxPHFitter` when `normalize=True`.
+ - removed  `normalize` kwarg in `CoxPHFitter`. This was causing lots of confusion for users, and added code complexity. It's really nice to be able to remove it.
+ - correcting column name in `CoxPHFitter.baseline_survival_`
+ - `CoxPHFitter.baseline_cumulative_hazard_` is always centered, to mimic R's `basehaz` API.
+ - new `predict_log_partial_hazards` to `CoxPHFitter`
+
+#### 0.9.4
+ - adding `plot_loglogs` to `KaplanMeierFitter`
+ - added a (correct) check to see if some columns in a dataset will cause convergence problems.
+ - removing `flat` argument in `plot` methods. It was causing confusion. To replicate it, one can set `ci_force_lines=True` and `show_censors=True`.
+ - adding `strata` keyword argument to `CoxPHFitter` on initialization (ex: `CoxPHFitter(strata=['v1', 'v2'])`. Why? Fitters initialized with `strata` can now be passed into `k_fold_cross_validation`, plus it makes unit testing `strata` fitters easier.
+ - If using `strata` in `CoxPHFitter`, access to strata specific baseline hazards and survival functions are available (previously it was a blended valie). Prediction also uses the specific baseline hazards/survivals.
+ - performance improvements in `CoxPHFitter` - should see at least a 10% speed improvement in `fit`.
+
+#### 0.9.2
+ - deprecates Pandas versions before 0.18.
+ - throw an error if no admissable pairs in the c-index calculation. Previously a NaN was returned.
+
+#### 0.9.1
+ - add two summary functions to Weibull and Exponential fitter, solves #224
+
+#### 0.9.0
+ - new prediction function in `CoxPHFitter`, `predict_log_hazard_relative_to_mean`, that mimics what R's `predict.coxph` does.
+ - removing the `predict` method in CoxPHFitter and AalenAdditiveFitter. This is because the choice of `predict_median` as a default was causing too much confusion, and no other natual choice as a default was available. All other `predict_` methods remain.
+ - Default predict method in `k_fold_cross_validation` is now `predict_expectation`
+
+#### 0.8.1 - 2015-08-01
+ - supports matplotlib 1.5.
+ - introduction of a param `nn_cumulative_hazards` in AalenAdditiveModel's `__init__` (default True). This parameter will truncate all non-negative cumulative hazards in prediction methods to 0.
+ - bug fixes including:
+    - fixed issue where the while loop in `_newton_rhaphson` would break too early causing a variable not to be set properly.
+    - scaling of smooth hazards in NelsonAalenFitter was off by a factor of 0.5.
+
+
+#### 0.8.0
+ - reorganized lifelines directories:
+    - moved test files out of main directory.
+    - moved `utils.py` into it's own directory.
+    - moved all estimators `fitters` directory.
+ - added a `at_risk` column to the output of `group_survival_table_from_events` and `survival_table_from_events`
+ - added sample size and power calculations for statistical tests. See `lifeline.statistics. sample_size_necessary_under_cph` and `lifelines.statistics. power_under_cph`.
+ - fixed a bug when using KaplanMeierFitter for left-censored data.
+
+
+#### 0.7.1
+- addition of a l2 `penalizer` to `CoxPHFitter`.
+- dropped Fortran implementation of efficient Python version. Lifelines is pure python once again!
+- addition of `strata` keyword argument to `CoxPHFitter` to allow for stratification of a single or set of
+categorical variables in your dataset.
+- `datetimes_to_durations` now accepts a list as `na_values`, so multiple values can be checked.
+- fixed a bug in `datetimes_to_durations` where `fill_date` was not properly being applied.
+- Changed warning in `datetimes_to_durations` to be correct.
+- refactor each fitter into it's own submodule. For now, the tests are still in the same file. This will also *not* break the API.
+
+
+#### 0.7.0 - 2015-03-01
+- allow for multiple fitters to be passed into `k_fold_cross_validation`.
+- statistical tests in `lifelines.statistics`. now return a `StatisticalResult` object with properties like `p_value`, `test_results`, and `summary`.
+- fixed a bug in how log-rank statistical tests are performed. The covariance matrix was not being correctly calculated. This resulted in slightly different p-values.
+- `WeibullFitter`, `ExponentialFitter`, `KaplanMeierFitter` and `BreslowFlemingHarringtonFitter` all have a `conditional_time_to_event_` property that measures  the median duration remaining until the death event, given survival up until time t.
+
+#### 0.6.1
+
+- addition of `median_` property to `WeibullFitter` and `ExponentialFitter`.
+- `WeibullFitter` and `ExponentialFitter` will use integer timelines instead of float provided by `linspace`. This is
+so if your work is to sum up the survival function (for expected values or something similar), it's more difficult to
+make a mistake.
+
+#### 0.6.0 - 2015-02-04
+
+- Inclusion of the univariate fitters `WeibullFitter` and `ExponentialFitter`.
+- Removing `BayesianFitter` from lifelines.
+- Added new penalization scheme to AalenAdditiveFitter. You can now add a smoothing penalizer
+that will try to keep subsequent values of a hazard curve close together. The penalizing coefficient
+is `smoothing_penalizer`.
+- Changed `penalizer` keyword arg to `coef_penalizer` in AalenAdditiveFitter.
+- new `ridge_regression` function in `utils.py` to perform linear regression with l2 penalizer terms.
+- Matplotlib is no longer a mandatory dependency.
+- `.predict(time)` method on univariate fitters can now accept a scalar (and returns a scalar) and an iterable (and returns a numpy array)
+- In `KaplanMeierFitter`, `epsilon` has been renamed to `precision`.
+
+
+#### 0.5.1 - 2014-12-24
+
+- New API for `CoxPHFitter` and `AalenAdditiveFitter`: the default arguments for `event_col` and `duration_col`. `duration_col` is now mandatory, and `event_col` now accepts a column, or by default, `None`, which assumes all events are observed (non-censored).
+- Fix statistical tests.
+- Allow negative durations in Fitters.
+- New API in `survival_table_from_events`: `min_observations` is replaced by `birth_times` (default `None`).
+- New API in `CoxPHFitter` for summary: `summary` will return a dataframe with statistics, `print_summary()` will print the dataframe (plus some other statistics) in a pretty manner.
+- Adding "At Risk" counts option to univariate fitter `plot` methods, `.plot(at_risk_counts=True)`, and the function `lifelines.plotting.add_at_risk_counts`.
+- Fix bug Epanechnikov kernel.
+
+#### 0.5.0 - 2014-12-07
+
+- move testing to py.test
+- refactor tests into smaller files
+- make `test_pairwise_logrank_test_with_identical_data_returns_inconclusive` a better test
+- add test for summary()
+- Alternate metrics can be used for `k_fold_cross_validation`.
+
+
+#### 0.4.4 - 2014-11-27
+
+ - Lots of improvements to numerical stability (but something things still need work)
+ - Additions to `summary` in CoxPHFitter.
+ - Make all prediction methods output a DataFrame
+ - Fixes bug in 1-d input not returning in CoxPHFitter
+ - Lots of new tests.
+
+#### 0.4.3 - 2014-07-23
+ - refactoring of `qth_survival_times`: it can now accept an iterable (or a scalar still) of probabilities in the q argument, and will return a DataFrame with these as columns. If len(q)==1 and a single survival function is given, will return a scalar, not a DataFrame. Also some good speed improvements.
+ - KaplanMeierFitter and NelsonAalenFitter now have a `_label` property that is passed in during the fit.
+ - KaplanMeierFitter/NelsonAalenFitter's inital `alpha` value is overwritten if a new `alpha` value is passed
+ in during the `fit`.
+ - New method for KaplanMeierFitter: `conditional_time_to`. This returns a DataFrame of the estimate:
+    med(S(t | T>s)) - s, human readable: the estimated time left of living, given an individual is aged s.
+- Adds option `include_likelihood` to CoxPHFitter fit method to save the final log-likelihood value.
+
+#### 0.4.2 - 2014-06-19
+
+ - Massive speed improvements to CoxPHFitter.
+ - Additional prediction method: `predict_percentile` is available on CoxPHFitter and AalenAdditiveFitter. Given a percentile, p, this function returns the value t such that *S(t | x) = p*. It is a generalization of `predict_median`.
+ - Additional kwargs in `k_fold_cross_validation` that will accept different prediction methods (default is `predict_median`).
+- Bug fix in CoxPHFitter `predict_expectation` function.
+- Correct spelling mistake in newton-rhapson algorithm.
+- `datasets` now contains functions for generating the respective datasets, ex: `generate_waltons_dataset`.
+- Bumping up the number of samples in statistical tests to prevent them from failing so often (this a stop-gap)
+- pep8 everything
+
+#### 0.4.1.1
+
+- Ability to specify default printing in statistical tests with the `suppress_print` keyword argument (default False).
+- For the multivariate log rank test, the inverse step has been replaced with the generalized inverse. This seems to be what other packages use.
+- Adding more robust cross validation scheme based on issue #67.
+- fixing `regression_dataset` in `datasets`.
+
+
+#### 0.4.1 - 2014-06-11
+
+ - `CoxFitter` is now known as `CoxPHFitter`
+ - refactoring some tests that used redundant data from `lifelines.datasets`.
+ - Adding cross validation: in `utils` is a new `k_fold_cross_validation` for model selection in regression problems.
+ - Change CoxPHFitter's fit method's `display_output` to `False`.
+ - fixing bug in CoxPHFitter's `_compute_baseline_hazard` that errored when sending Series objects to
+   `survival_table_from_events`.
+ - CoxPHFitter's `fit` now looks to columns with too low variance, and halts NR algorithm if a NaN is found.
+ - Adding a Changelog.
+ - more sanitizing for the statistical tests =)
+
+#### 0.4.0 - 2014-06-08
+
+ - `CoxFitter` implements Cox Proportional Hazards model in lifelines.
+ - lifelines moves the wheels distributions.
+ - tests in the `statistics` module now prints the summary (and still return the regular values)
+ - new `BaseFitter` class is inherited from all fitters.

lifelines/source/CITATION.cff

@@ -0,0 +1,14 @@
+# YAML 1.2
+---
+authors:
+  -
+    family-names: "Davidson-Pilon"
+    given-names: Cameron
+    orcid: "https://orcid.org/0000-0003-1794-9143"
+cff-version: "1.1.0"
+doi: "https://doi.org/10.21105/joss.01317"
+license: MIT
+message: "If you use this software, please cite it using these metadata."
+repository-code: "https://github.com/camDavidsonPilon/lifelines"
+title: lifelines, survival analysis in Python
+...

lifelines/source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Cameron Davidson-Pilon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lifelines/source/MANIFEST.in

@@ -0,0 +1,12 @@
+include README.md
+include LICENSE
+include MANIFEST.in
+
+include *.ipynb
+
+recursive-include lifelines *
+recursive-include datasets *
+recursive-include styles *
+recursive-include reqs *
+
+recursive-exclude * *.py[co]

lifelines/source/Makefile

@@ -0,0 +1,38 @@
+init:
+ifeq ($(TRAVIS), true)
+		pip install -r reqs/travis-requirements.txt
+		pip install pandas==${PANDAS_VERSION}
+		pip install numpy==${NUMPY_VERSION}
+		pip freeze --local
+else
+		pip install -r reqs/dev-requirements.txt
+		pre-commit install
+endif
+
+test:
+	py.test lifelines/ -rfs --cov=lifelines --block=False --cov-report term-missing
+
+lint:
+ifeq ($(TRAVIS_PYTHON_VERSION), 2.7)
+		echo "Skip linting for Python2.7"
+else
+		make black
+		prospector --output-format grouped
+endif
+
+black:
+ifeq ($(TRAVIS_PYTHON_VERSION), 2.7)
+		echo "Skip linting for Python2.7"
+else
+		black lifelines/ -l 120 --fast
+endif
+
+check_format:
+ifeq ($(TRAVIS_PYTHON_VERSION), 3.6)
+		black . --check --line-length 120
+else
+		echo "Only check format on Python3.6"
+endif
+
+pre:
+	pre-commit run --all-files

lifelines/source/README.md

@@ -0,0 +1,32 @@
+![](http://i.imgur.com/EOowdSD.png)
+
+[![PyPI version](https://badge.fury.io/py/lifelines.svg)](https://badge.fury.io/py/lifelines)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/lifelines/badges/version.svg
+)](https://conda.anaconda.org/conda-forge)
+[![DOI](https://zenodo.org/badge/12420595.svg)](https://zenodo.org/badge/latestdoi/12420595)
+
+
+[What is survival analysis and why should I learn it?](http://lifelines.readthedocs.org/en/latest/Survival%20Analysis%20intro.html)
+ Survival analysis was originally developed and applied heavily by the actuarial and medical community. Its purpose was to answer *why do events occur now versus later* under uncertainty (where *events* might refer to deaths, disease remission, etc.). This is great for researchers who are interested in measuring lifetimes: they can answer questions like *what factors might influence deaths?*
+
+But outside of medicine and actuarial science, there are many other interesting and exciting applications of survival analysis. For example:
+- SaaS providers are interested in measuring subscriber lifetimes, or time to some first action
+- inventory stock out is a censoring event for true "demand" of a good.
+- sociologists are interested in measuring political parties' lifetimes, or relationships, or marriages
+- A/B tests to determine how long it takes different groups to perform an action.
+
+*lifelines* is a pure Python implementation of the best parts of survival analysis.
+
+
+## Documentation and intro to survival analysis
+
+If you are new to survival analysis, wondering why it is useful, or are interested in *lifelines* examples, API, and syntax, please read the [Documentation and Tutorials page](http://lifelines.readthedocs.org/en/latest/index.html)
+
+## Contact
+ - Start a conversation in our [Discussions room](https://github.com/CamDavidsonPilon/lifelines/discussions).
+ - Some users have posted common questions at [stats.stackexchange.com](https://stats.stackexchange.com/search?tab=votes&q=%22lifelines%22%20is%3aquestion).
+ - Creating an issue in the [Github repository](https://github.com/camdavidsonpilon/lifelines).
+
+## Development
+
+See our [Contributing](https://github.com/CamDavidsonPilon/lifelines/blob/master/.github/CONTRIBUTING.md) guidelines.

lifelines/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+lifelines Project Package Initialization File
+"""

lifelines/source/conftest.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import pytest
+
+
+def pytest_runtest_setup(item):
+    random_seed = np.random.randint(1000)
+    print("Seed used in np.random.seed(): %d" % random_seed)
+    np.random.seed(random_seed)
+
+
+def pytest_addoption(parser):
+    parser.addoption("--block", action="store", default=True, help="Should plotting block or not.")
+
+
+@pytest.fixture
+def block(request):
+    try:
+        return request.config.getoption("--block") not in "False,false,no,0".split(",")
+    except ValueError:
+        return True

lifelines/source/docs/Changelog.rst

@@ -0,0 +1,2822 @@
+Changelog
+=========
+
+0.28.0 - Upcoming
+-----------------
+
+-  Fixes bins that are far into the future with using
+   ``survival_table_from_events``, see #1587
+-  Removed ``sklean_adaptor``. It was a terrible hack, and causing more
+   confusion and support debt than I want. This cleans up our API and
+   simplifies the library. ✨ There’s no replacement, and I doubt I’ll
+   introduce one ✨
+-  Fix Pandas 2.0 compatibility.
+-  Fix overflow issue in NelsonAalenfitter, #1585
+
+0.27.8 - 2023-09-13
+-------------------
+
+-  Estimators now have ``.label`` property
+-  Fixed some deprecation warnings
+-  Pinned to numpy < 2.0
+
+.. _section-1:
+
+0.27.7 - 2023-05-01
+-------------------
+
+-  ``check_assumptions(show_plots=True)`` will always show plots,
+   regardless of test outcome. Thanks @nomennominatur!
+-  ``lifelines.datasets`` is now importable.
+
+.. _section-2:
+
+0.27.6 - 2023-04-27
+-------------------
+
+-  Fix for py3.7
+
+.. _section-3:
+
+0.27.5 - 2023-04-27
+-------------------
+
+-  Support pandas 2.0+
+
+New features
+~~~~~~~~~~~~
+
+-  Support py3.11
+
+.. _section-4:
+
+0.27.4 - 2022-11-16
+-------------------
+
+.. _new-features-1:
+
+New features
+~~~~~~~~~~~~
+
+-  Support py3.11
+
+.. _section-5:
+
+0.27.3 - 2022-09-25
+-------------------
+
+.. _new-features-2:
+
+New features
+~~~~~~~~~~~~
+
+-  Fixed and silenced a lot of warnings
+
+Bug fixes
+~~~~~~~~~
+
+-  Migrate to newer Pandas ``Styler`` for ``to_latex``
+
+API Changes
+~~~~~~~~~~~
+
+-  There were way too many functions on the summary objects, so I’ve
+   hidden ``to_*`` on them.
+
+.. _section-6:
+
+0.27.2 - 2022-09-07
+-------------------
+
+.. _bug-fixes-1:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed issue in add_at_risk_table when there were very late entries.
+
+.. _section-7:
+
+0.27.1 - 2022-06-25
+-------------------
+
+.. _new-features-3:
+
+New features
+~~~~~~~~~~~~
+
+-  all ``fit_`` methods now accept a ``fit_options`` dict that allows
+   one to pass kwargs to the underlying fitting algorithm.
+
+.. _api-changes-1:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``step_size`` is removed from Cox models ``fit``. See ``fit_options``
+   above.
+
+.. _bug-fixes-2:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed Cox models when “trivial” matrix was passed in (one with no
+   covariates)
+
+.. _section-8:
+
+0.27.0 - 2022-03-15
+-------------------
+
+Dropping Python3.6 support.
+
+.. _bug-fixes-3:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fix late entry in ``add_at_risk_counts``.
+
+.. _new-features-4:
+
+New features
+~~~~~~~~~~~~
+
+-  ``add_at_risk_counts`` has a new flag to determine to use start or
+   end-of-period at risk counts.
+-  new column in fitter’s ``summary`` that display the number the
+   parameter is being compared against.
+
+.. _api-changes-2:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``plot_lifetimes``\ ’s ``duration`` arg has the interpretation of
+   “relative time the subject died (since birth)”, instead of the old
+   “time observed for”. These interpretations are different when there
+   is late entry.
+
+.. _section-9:
+
+0.26.4 - 2021-11-30
+-------------------
+
+.. _new-features-5:
+
+New features
+~~~~~~~~~~~~
+
+-  adding ``weights`` to log rank functions
+
+.. _section-10:
+
+0.26.3 - 2021-09-16
+-------------------
+
+.. _bug-fixes-4:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fix using formulas with ``CoxPHFitter.score``
+
+.. _section-11:
+
+0.26.2 - 2021-09-15
+-------------------
+
+Error in v0.26.1 deployment
+
+.. _section-12:
+
+0.26.1 - 2021-09-15
+-------------------
+
+.. _api-changes-3:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``t_0`` in ``logrank_test`` now will not remove data, but will
+   instead censor all subjects that experience the event afterwards.
+-  update ``status`` column in ``lifelines.datasets.load_lung`` to be
+   more standard coding: 0 is censored, 1 is event.
+
+.. _bug-fixes-5:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fix using formulas with
+   ``AalenAdditiveFitter.predict_cumulative_hazard``
+-  Fix using formulas with ``CoxPHFitter.score``
+
+.. _section-13:
+
+0.26.0 - 2021-05-26
+-------------------
+
+.. _new-features-6:
+
+New features
+~~~~~~~~~~~~
+
+-  ``.BIC_`` is now present on fitted models.
+-  ``CoxPHFitter`` with spline baseline can accept pre-computed knot
+   locations.
+-  Left censoring fitting in KaplanMeierFitter is now “expected”. That
+   is, ``predict`` *always* predicts the survival function (as does
+   every other model), ``confidence_interval_`` is *always* the CI for
+   the survival function (as does every other model), and so on. In
+   summary: the API for estimates doesn’t change depending on what your
+   censoring your dataset is.
+
+.. _bug-fixes-6:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed an annoying bug where at_risk-table label’s were not aligning
+   properly when data spanned large ranges. See merging PR for details.
+-  Fixed a bug in ``find_best_parametric_model`` where the wrong BIC
+   value was being computed.
+-  Fixed regression bug when using an array as a penalizer in Cox
+   models.
+
+.. _section-14:
+
+0.25.11 - 2021-04-06
+--------------------
+
+.. _bug-fixes-7:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fix integer-valued categorical variables in regression model
+   predictions.
+-  numpy > 1.20 is allowed.
+-  Bug fix in the elastic-net penalty for Cox models that wasn’t
+   weighting the terms correctly.
+
+.. _section-15:
+
+0.25.10 - 2021-03-03
+--------------------
+
+.. _new-features-7:
+
+New features
+~~~~~~~~~~~~
+
+-  Better appearance when using a single row to show in
+   ``add_at_risk_table``.
+
+.. _section-16:
+
+0.25.9 - 2021-02-04
+-------------------
+
+Small bump in dependencies.
+
+.. _section-17:
+
+0.25.8 - 2021-01-22
+-------------------
+
+Important: we dropped Patsy as our formula framework, and adopted
+Formulaic. Will the latter is less mature than Patsy, we feel the core
+capabilities are satisfactory and it provides new opportunities.
+
+.. _new-features-8:
+
+New features
+~~~~~~~~~~~~
+
+-  Parametric models with formulas are able to be serialized now.
+-  a ``_scipy_callback`` function is available to use in fitting
+   algorithms.
+
+.. _section-18:
+
+0.25.7 - 2020-12-09
+-------------------
+
+.. _api-changes-4:
+
+API Changes
+~~~~~~~~~~~
+
+-  Adding ``cumulative_hazard_at_times`` to NelsonAalenFitter
+
+.. _bug-fixes-8:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed error in ``CoxPHFitter`` when entry time == event time.
+-  Fixed formulas in AFT interval censoring regression.
+-  Fixed ``concordance_index_`` when no events observed
+-  Fixed label being overwritten in ParametricUnivariate models
+
+.. _section-19:
+
+0.25.6 - 2020-10-26
+-------------------
+
+.. _new-features-9:
+
+New features
+~~~~~~~~~~~~
+
+-  Parametric Cox models can now handle left and interval censoring
+   datasets.
+
+.. _bug-fixes-9:
+
+Bug fixes
+~~~~~~~~~
+
+-  “improved” the output of ``add_at_risk_counts`` by removing a call to
+   ``plt.tight_layout()`` - this works better when you are calling
+   ``add_at_risk_counts`` on multiple axes, but it is recommended you
+   call ``plt.tight_layout()`` at the very end of your script.
+-  Fix bug in ``KaplanMeierFitter``\ ’s interval censoring where
+   max(lower bound) < min(upper bound).
+
+.. _section-20:
+
+0.25.5 - 2020-09-23
+-------------------
+
+.. _api-changes-5:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``check_assumptions`` now returns a list of list of axes that can be
+   manipulated
+
+.. _bug-fixes-10:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed error when using ``plot_partial_effects`` with categorical data
+   in AFT models
+-  improved warning when Hessian matrix contains NaNs.
+-  fixed performance regression in interval censoring fitting in
+   parametric models
+-  ``weights`` wasn’t being applied properly in NPMLE
+
+.. _section-21:
+
+0.25.4 - 2020-08-26
+-------------------
+
+.. _new-features-10:
+
+New features
+~~~~~~~~~~~~
+
+-  New baseline estimator for Cox models: ``piecewise``
+-  Performance improvements for parametric models
+   ``log_likelihood_ratio_test()`` and ``print_summary()``
+-  Better step-size defaults for Cox model -> more robust convergence.
+
+.. _bug-fixes-11:
+
+Bug fixes
+~~~~~~~~~
+
+-  fix ``check_assumptions`` when using formulas.
+
+.. _section-22:
+
+0.25.3 - 2020-08-24
+-------------------
+
+.. _new-features-11:
+
+New features
+~~~~~~~~~~~~
+
+-  ``survival_difference_at_fixed_point_in_time_test`` now accepts
+   fitters instead of raw data, meaning that you can use this function
+   on left, right or interval censored data.
+
+.. _api-changes-6:
+
+API Changes
+~~~~~~~~~~~
+
+-  See note on ``survival_difference_at_fixed_point_in_time_test``
+   above.
+
+.. _bug-fixes-12:
+
+Bug fixes
+~~~~~~~~~
+
+-  fix ``StatisticalResult`` printing in notebooks
+-  fix Python error when calling ``plot_covariate_groups``
+-  fix dtype mismatches in ``plot_partial_effects_on_outcome``.
+
+.. _section-23:
+
+0.25.2 - 2020-08-08
+-------------------
+
+.. _new-features-12:
+
+New features
+~~~~~~~~~~~~
+
+-  Spline ``CoxPHFitter`` can now use ``strata``.
+
+.. _api-changes-7:
+
+API Changes
+~~~~~~~~~~~
+
+-  a small parameterization change of the spline ``CoxPHFitter``. The
+   linear term in the spline part was moved to a new ``Intercept`` term
+   in the ``beta_``.
+-  ``n_baseline_knots`` in the spline ``CoxPHFitter`` now refers to
+   *all* knots, and not just interior knots (this was confusing to me,
+   the author.). So add 2 to ``n_baseline_knots`` to recover the
+   identical model as previously.
+
+.. _bug-fixes-13:
+
+Bug fixes
+~~~~~~~~~
+
+-  fix splines ``CoxPHFitter`` with when ``predict_hazard`` was called.
+-  fix some exception imports I missed.
+-  fix log-likelihood p-value in splines ``CoxPHFitter``
+
+.. _section-24:
+
+0.25.1 - 2020-08-01
+-------------------
+
+.. _bug-fixes-14:
+
+Bug fixes
+~~~~~~~~~
+
+-  ok *actually* ship the out-of-sample calibration code
+-  fix ``labels=False`` in ``add_at_risk_counts``
+-  allow for specific rows to be shown in ``add_at_risk_counts``
+-  put ``patsy`` as a proper dependency.
+-  suppress some Pandas 1.1 warnings.
+
+.. _section-25:
+
+0.25.0 - 2020-07-27
+-------------------
+
+.. _new-features-13:
+
+New features
+~~~~~~~~~~~~
+
+-  Formulas! *lifelines* now supports R-like formulas in regression
+   models. See docs
+   `here <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#fitting-the-regression>`__.
+-  ``plot_covariate_group`` now can plot other y-values like hazards and
+   cumulative hazards (default: survival function).
+-  ``CoxPHFitter`` now accepts late entries via ``entry_col``.
+-  ``calibration.survival_probability_calibration`` now works with
+   out-of-sample data.
+-  ``print_summary`` now accepts a ``column`` argument to filter down
+   the displayed values. This helps with clutter in notebooks, latex, or
+   on the terminal.
+-  ``add_at_risk_counts`` now follows the cool new KMunicate suggestions
+
+.. _api-changes-8:
+
+API Changes
+~~~~~~~~~~~
+
+-  With the introduction of formulas, all models can be using formulas
+   under the hood.
+
+   -  For both custom regression models or non-AFT regression models,
+      this means that you no longer need to add a constant column to
+      your DataFrame (instead add a ``1`` as a formula string in the
+      ``regressors`` dict). You may also need to remove the T and E
+      columns from ``regressors``. I’ve updated the models in the
+      ``\examples`` folder with examples of this new model building.
+
+-  Unfortunately, if using formulas, your model will not be able to be
+   pickled. This is a problem with an upstream library, and I hope to
+   have it resolved in the near future.
+-  ``plot_covariate_groups`` has been deprecated in favour of
+   ``plot_partial_effects_on_outcome``.
+-  The baseline in ``plot_covariate_groups`` has changed from the *mean*
+   observation (including dummy-encoded categorical variables) to
+   *median* for ordinal (including continuous) and *mode* for
+   categorical.
+-  Previously, *lifelines* used the label ``"_intercept"`` to when it
+   added a constant column in regressions. To align with Patsy, we are
+   now using ``"Intercept"``.
+-  In AFT models, ``ancillary_df`` kwarg has been renamed to
+   ``ancillary``. This reflects the more general use of the kwarg (not
+   always a DataFrame, but could be a boolean or string now, too).
+-  Some column names in datasets shipped with lifelines have changed.
+-  The never used “lifelines.metrics” is deleted.
+-  With the introduction of formulas, ``plot_covariate_groups`` (now
+   called ``plot_partial_effects_on_outcome``) behaves differently for
+   transformed variables. Users no longer need to add “derivatives”
+   features, and encoding is done implicitly. See docs
+   `here <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#plotting-the-effect-of-varying-a-covariate>`__.
+-  all exceptions and warnings have moved to ``lifelines.exceptions``
+
+.. _bug-fixes-15:
+
+Bug fixes
+~~~~~~~~~
+
+-  The p-value of the log-likelihood ratio test for the CoxPHFitter with
+   splines was returning the wrong result because the degrees of freedom
+   was incorrect.
+-  better ``print_summary`` logic in IDEs and Jupyter exports.
+   Previously it should not be displayed.
+-  p-values have been corrected in the ``SplineFitter``. Previously, the
+   “null hypothesis” was no coefficient=0, but coefficient=0.01. This is
+   now set to the former.
+-  fixed NaN bug in ``survival_table_from_events`` with intervals when
+   no events would occur in a interval.
+
+.. _section-26:
+
+0.24.16 - 2020-07-09
+--------------------
+
+.. _new-features-14:
+
+New features
+~~~~~~~~~~~~
+
+-  improved algorithm choice for large DataFrames for Cox models. Should
+   see a significant performance boost.
+
+.. _bug-fixes-16:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed ``utils.median_survival_time`` not accepting Pandas Series.
+
+.. _section-27:
+
+0.24.15 - 2020-07-07
+--------------------
+
+.. _bug-fixes-17:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed an edge case in ``KaplanMeierFitter`` where a really late entry
+   would occur after all other population had died.
+-  fixed ``plot`` in ``BreslowFlemingtonHarrisFitter``
+-  fixed bug where using ``conditional_after`` and ``times`` in
+   ``CoxPHFitter("spline")`` prediction methods would be ignored.
+
+.. _section-28:
+
+0.24.14 - 2020-07-02
+--------------------
+
+.. _bug-fixes-18:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed a bug where using ``conditional_after`` and ``times`` in
+   prediction methods would result in a shape error
+-  fixed a bug where ``score`` was not able to be used in splined
+   ``CoxPHFitter``
+-  fixed a bug where some columns would not be displayed in
+   ``print_summary``
+
+.. _section-29:
+
+0.24.13 - 2020-06-22
+--------------------
+
+.. _bug-fixes-19:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed a bug where ``CoxPHFitter`` would ignore inputed ``alpha``
+   levels for confidence intervals
+-  fixed a bug where ``CoxPHFitter`` would fail with working with
+   ``sklearn_adapter``
+
+.. _section-30:
+
+0.24.12 - 2020-06-20
+--------------------
+
+.. _new-features-15:
+
+New features
+~~~~~~~~~~~~
+
+-  improved convergence of ``GeneralizedGamma(Regression)Fitter``.
+
+.. _section-31:
+
+0.24.11 - 2020-06-17
+--------------------
+
+.. _new-features-16:
+
+New features
+~~~~~~~~~~~~
+
+-  new spline regression model ``CRCSplineFitter`` based on the paper “A
+   flexible parametric accelerated failure time model” by Michael J.
+   Crowther, Patrick Royston, Mark Clements.
+-  new survival probability calibration tool
+   ``lifelines.calibration.survival_probability_calibration`` to help
+   validate regression models. Based on “Graphical calibration curves
+   and the integrated calibration index (ICI) for survival models” by P.
+   Austin, F. Harrell, and D. van Klaveren.
+
+.. _api-changes-9:
+
+API Changes
+~~~~~~~~~~~
+
+-  (and bug fix) scalar parameters in regression models were not being
+   penalized by ``penalizer`` - we now penalizing everything except
+   intercept terms in linear relationships.
+
+.. _section-32:
+
+0.24.10 - 2020-06-16
+--------------------
+
+.. _new-features-17:
+
+New features
+~~~~~~~~~~~~
+
+-  New improvements when using splines model in CoxPHFitter - it should
+   offer much better prediction and baseline-hazard estimation,
+   including extrapolation and interpolation.
+
+.. _api-changes-10:
+
+API Changes
+~~~~~~~~~~~
+
+-  Related to above: the fitted spline parameters are now available in
+   the ``.summary`` and ``.print_summary`` methods.
+
+.. _bug-fixes-20:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed a bug in initialization of some interval-censoring models ->
+   better convergence.
+
+.. _section-33:
+
+0.24.9 - 2020-06-05
+-------------------
+
+.. _new-features-18:
+
+New features
+~~~~~~~~~~~~
+
+-  Faster NPMLE for interval censored data
+-  New weightings available in the ``logrank_test``: ``wilcoxon``,
+   ``tarone-ware``, ``peto``, ``fleming-harrington``. Thanks @sean-reed
+-  new interval censored dataset: ``lifelines.datasets.load_mice``
+
+.. _bug-fixes-21:
+
+Bug fixes
+~~~~~~~~~
+
+-  Cleared up some mislabeling in ``plot_loglogs``. Thanks @sean-reed!
+-  tuples are now able to be used as input in univariate models.
+
+.. _section-34:
+
+0.24.8 - 2020-05-17
+-------------------
+
+.. _new-features-19:
+
+New features
+~~~~~~~~~~~~
+
+-  Non parametric interval censoring is now available, *experimentally*.
+   Not all edge cases are fully checked, and some features are missing.
+   Try it under ``KaplanMeierFitter.fit_interval_censoring``
+
+.. _section-35:
+
+0.24.7 - 2020-05-17
+-------------------
+
+.. _new-features-20:
+
+New features
+~~~~~~~~~~~~
+
+-  ``find_best_parametric_model`` can handle left and interval
+   censoring. Also allows for more fitting options.
+-  ``AIC_`` is a property on parametric models, and ``AIC_partial_`` is
+   a property on Cox models.
+-  ``penalizer`` in all regression models can now be an array instead of
+   a float. This enables new functionality and better control over
+   penalization. This is similar (but not identical) to
+   ``penalty.factors`` in glmnet in R.
+-  some convergence tweaks which should help recent performance
+   regressions.
+
+.. _section-36:
+
+0.24.6 - 2020-05-05
+-------------------
+
+.. _new-features-21:
+
+New features
+~~~~~~~~~~~~
+
+-  At the cost of some performance, convergence is improved in many
+   models.
+-  New ``lifelines.plotting.plot_interval_censored_lifetimes`` for
+   plotting interval censored data - thanks @sean-reed!
+
+.. _bug-fixes-22:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed bug where ``cdf_plot`` and ``qq_plot`` were not factoring in
+   the weights correctly.
+
+.. _section-37:
+
+0.24.5 - 2020-05-01
+-------------------
+
+.. _new-features-22:
+
+New features
+~~~~~~~~~~~~
+
+-  ``plot_lifetimes`` accepts pandas Series.
+
+.. _bug-fixes-23:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed important bug in interval censoring models. Users using
+   interval censoring are strongly advised to upgrade.
+-  Improved ``at_risk_counts`` for subplots.
+-  More data validation checks for ``CoxTimeVaryingFitter``
+
+.. _section-38:
+
+0.24.4 - 2020-04-13
+-------------------
+
+.. _bug-fixes-24:
+
+Bug fixes
+~~~~~~~~~
+
+-  Improved stability of interval censoring in parametric models.
+-  setting a dataframe in ``ancillary_df`` works for interval censoring
+-  ``.score`` works for interval censored models
+
+.. _section-39:
+
+0.24.3 - 2020-03-25
+-------------------
+
+.. _new-features-23:
+
+New features
+~~~~~~~~~~~~
+
+-  new ``logx`` kwarg in plotting curves
+-  PH models have ``compute_followup_hazard_ratios`` for simulating what
+   the hazard ratio would be at previous times. This is useful because
+   the final hazard ratio is some weighted average of these.
+
+.. _bug-fixes-25:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed error in HTML printer that was hiding concordance index
+   information.
+
+.. _section-40:
+
+0.24.2 - 2020-03-15
+-------------------
+
+.. _bug-fixes-26:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed bug when no covariates were passed into ``CoxPHFitter``. See
+   #975
+-  Fixed error in ``StatisticalResult`` where the test name was not
+   displayed correctly.
+-  Fixed a keyword bug in ``plot_covariate_groups`` for parametric
+   models.
+
+.. _section-41:
+
+0.24.1 - 2020-03-05
+-------------------
+
+.. _new-features-24:
+
+New features
+~~~~~~~~~~~~
+
+-  Stability improvements for GeneralizedGammaRegressionFitter and
+   CoxPHFitter with spline estimation.
+
+.. _bug-fixes-27:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed bug with plotting hazards in NelsonAalenFitter.
+
+.. _section-42:
+
+0.24.0 - 2020-02-20
+-------------------
+
+This version and future versions of lifelines no longer support py35.
+Pandas 1.0 is fully supported, along with previous versions. Minimum
+Scipy has been bumped to 1.2.0.
+
+.. _new-features-25:
+
+New features
+~~~~~~~~~~~~
+
+-  ``CoxPHFitter`` and ``CoxTimeVaryingFitter`` has support for an
+   elastic net penalty, which includes L1 and L2 regression.
+-  ``CoxPHFitter`` has new baseline survival estimation methods.
+   Specifically, ``spline`` now estimates the coefficients and baseline
+   survival using splines. The traditional method, ``breslow``, is still
+   the default however.
+-  Regression models have a new ``score`` method that will score your
+   model against a dataset (ex: a testing or validation dataset). The
+   default is to evaluate the log-likelihood, but also the concordance
+   index can be chose.
+-  New ``MixtureCureFitter`` for quickly creating univariate mixture
+   models.
+-  Univariate parametric models have a ``plot_density``,
+   ``density_at_times``, and property ``density_`` that computes the
+   probability density function estimates.
+-  new dataset for interval regression involving *C. Botulinum*.
+-  new ``lifelines.fitters.mixins.ProportionalHazardMixin`` that
+   implements proportional hazard checks.
+
+.. _api-changes-11:
+
+API Changes
+~~~~~~~~~~~
+
+-  Models’ prediction method that return a single array now return a
+   Series (use to return a DataFrame). This includes ``predict_median``,
+   ``predict_percentile``, ``predict_expectation``,
+   ``predict_log_partial_hazard``, and possibly others.
+-  The penalty in Cox models is now scaled by the number of
+   observations. This makes it invariant to changing sample sizes. This
+   change also make the penalty magnitude behave the same as any
+   parametric regression model.
+-  ``score_`` on models has been renamed ``concordance_index_``
+-  models’ ``.variance_matrix_`` is now a DataFrame.
+-  ``CoxTimeVaryingFitter`` no longer requires an ``id_col``. It’s
+   optional, and some checks may be done for integrity if provided.
+-  Significant changes to ``utils.k_fold_cross_validation``.
+-  removed automatically adding ``inf`` from
+   ``PiecewiseExponentialRegressionFitter.breakpoints`` and
+   ``PiecewiseExponentialFitter.breakpoints``
+-  ``tie_method`` was dropped from Cox models (it was always Efron
+   anyways…)
+-  Mixins are moved to ``lifelines.fitters.mixins``
+-  ``find_best_parametric_model`` ``evaluation`` kwarg has been changed
+   to ``scoring_method``.
+-  removed ``_score_`` and ``path`` from Cox model.
+
+.. _bug-fixes-28:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed ``show_censors`` with
+   ``KaplanMeierFitter.plot_cumulative_density`` see issue #940.
+-  Fixed error in ``"BIC"`` code path in ``find_best_parametric_model``
+-  Fixed a bug where left censoring in AFT models was not converging
+   well
+-  Cox models now incorporate any penalizers in their
+   ``log_likelihood_``
+
+.. _section-43:
+
+0.23.9 - 2020-01-28
+-------------------
+
+.. _bug-fixes-29:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed important error when a parametric regression model would not
+   assign the correct labels to fitted parameters’ variances. See more
+   here: https://github.com/CamDavidsonPilon/lifelines/issues/931. Users
+   of ``GeneralizedGammaRegressionFitter`` and any custom regression
+   models should update their code as soon as possible.
+
+.. _section-44:
+
+0.23.8 - 2020-01-21
+-------------------
+
+.. _bug-fixes-30:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed important error when a parametric regression model would not
+   assign the correct labels to fitted parameters. See more here:
+   https://github.com/CamDavidsonPilon/lifelines/issues/931. Users of
+   ``GeneralizedGammaRegressionFitter`` and any custom regression models
+   should update their code as soon as possible.
+
+.. _section-45:
+
+0.23.7 - 2020-01-14
+-------------------
+
+Bug fixes for py3.5.
+
+.. _section-46:
+
+0.23.6 - 2020-01-07
+-------------------
+
+.. _new-features-26:
+
+New features
+~~~~~~~~~~~~
+
+-  New univariate model, ``SplineFitter``, that uses cubic splines to
+   model the cumulative hazard.
+-  To aid users with selecting the best parametric model, there is a new
+   ``lifelines.utils.find_best_parametric_model`` function that will
+   iterate through the models and return the model with the lowest AIC
+   (by default).
+-  custom parametric regression models can now do left and interval
+   censoring.
+
+.. _section-47:
+
+0.23.5 - 2020-01-05
+-------------------
+
+.. _new-features-27:
+
+New features
+~~~~~~~~~~~~
+
+-  New ``predict_hazard`` for parametric regression models.
+-  New lymph node cancer dataset, originally from *H.F. for the German
+   Breast Cancer Study Group (GBSG) (1994)*
+
+.. _bug-fixes-31:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixes error thrown when converge of regression models fails.
+-  ``kwargs`` is now used in ``plot_covariate_groups``
+-  fixed bug where large exponential numbers in ``print_summary`` were
+   not being suppressed correctly.
+
+.. _section-48:
+
+0.23.4 - 2019-12-15
+-------------------
+
+-  Bug fix for PyPI
+
+.. _section-49:
+
+0.23.3 - 2019-12-11
+-------------------
+
+.. _new-features-28:
+
+New features
+~~~~~~~~~~~~
+
+-  ``StatisticalResult.print_summary`` supports html output.
+
+.. _bug-fixes-32:
+
+Bug fixes
+~~~~~~~~~
+
+-  fix import in ``printer.py``
+-  fix html printing with Univariate models.
+
+.. _section-50:
+
+0.23.2 - 2019-12-07
+-------------------
+
+.. _new-features-29:
+
+New features
+~~~~~~~~~~~~
+
+-  new ``lifelines.plotting.rmst_plot`` for pretty figures of survival
+   curves and RMSTs.
+-  new variance calculations for
+   ``lifelines.utils.restricted_mean_survival_time``
+-  performance improvements on regression models’ preprocessing. Should
+   make datasets with high number of columns more performant.
+
+.. _bug-fixes-33:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed ``print_summary`` for AAF class.
+-  fixed repr for ``sklearn_adapter`` classes.
+-  fixed ``conditional_after`` in Cox model with strata was used.
+
+.. _section-51:
+
+0.23.1 - 2019-11-27
+-------------------
+
+.. _new-features-30:
+
+New features
+~~~~~~~~~~~~
+
+-  new ``print_summary`` option ``style`` to print HTML, LaTeX or ASCII
+   output
+-  performance improvements for ``CoxPHFitter`` - up to 30% performance
+   improvements for some datasets.
+
+.. _bug-fixes-34:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed bug where computed statistics were not being shown in
+   ``print_summary`` for HTML output.
+-  fixed bug where “None” was displayed in models’ ``__repr__``
+-  fixed bug in ``StatisticalResult.print_summary``
+-  fixed bug when using ``print_summary`` with left censored models.
+-  lots of minor bug fixes.
+
+.. _section-52:
+
+0.23.0 - 2019-11-17
+-------------------
+
+.. _new-features-31:
+
+New features
+~~~~~~~~~~~~
+
+-  new ``print_summary`` abstraction that allows HTML printing in
+   Jupyter notebooks!
+-  silenced some warnings.
+
+.. _bug-fixes-35:
+
+Bug fixes
+~~~~~~~~~
+
+-  The “comparison” value of some parametric univariate models wasn’t
+   standard, so the null hypothesis p-value may have been wrong. This is
+   now fixed.
+-  fixed a NaN error in confidence intervals for KaplanMeierFitter
+
+.. _api-changes-12:
+
+API Changes
+~~~~~~~~~~~
+
+-  To align values across models, the column names for the confidence
+   intervals in parametric univariate models ``summary`` have changed.
+-  Fixed typo in ``ParametricUnivariateFitter`` name.
+-  ``median_`` has been removed in favour of ``median_survival_time_``.
+-  ``left_censorship`` in ``fit`` has been removed in favour of
+   ``fit_left_censoring``.
+
+.. _section-53:
+
+0.22.10 - 2019-11-08
+--------------------
+
+The tests were re-factored to be shipped with the package. Let me know
+if this causes problems.
+
+.. _bug-fixes-36:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed error in plotting models with “lower” or “upper” was in the
+   label name.
+-  fixed bug in plot_covariate_groups for AFT models when >1d arrays
+   were used for values arg.
+
+.. _section-54:
+
+0.22.9 - 2019-10-30
+-------------------
+
+.. _bug-fixes-37:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed ``predict_`` methods in AFT models when ``timeline`` was not
+   specified.
+-  fixed error in ``qq_plot``
+-  fixed error when submitting a model in ``qth_survival_time``
+-  ``CoxPHFitter`` now displays correct columns values when changing
+   alpha param.
+
+.. _section-55:
+
+0.22.8 - 2019-10-06
+-------------------
+
+.. _new-features-32:
+
+New features
+~~~~~~~~~~~~
+
+-  Serializing lifelines is better supported. Packages like joblib and
+   pickle are now supported. Thanks @AbdealiJK!
+-  ``conditional_after`` now available in ``CoxPHFitter.predict_median``
+-  Suppressed some unimportant warnings.
+
+.. _bug-fixes-38:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed initial_point being ignored in AFT models.
+
+.. _section-56:
+
+0.22.7 - 2019-09-29
+-------------------
+
+.. _new-features-33:
+
+New features
+~~~~~~~~~~~~
+
+-  new ``ApproximationWarning`` to tell you if the package is making an
+   potentially mislead approximation.
+
+.. _bug-fixes-39:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed a bug in parametric prediction for interval censored data.
+-  realigned values in ``print_summary``.
+-  fixed bug in ``survival_difference_at_fixed_point_in_time_test``
+
+.. _api-changes-13:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``utils.qth_survival_time`` no longer takes a ``cdf`` argument -
+   users should take the compliment (1-cdf).
+-  Some previous ``StatisticalWarnings`` have been replaced by
+   ``ApproximationWarning``
+
+.. _section-57:
+
+0.22.6 - 2019-09-25
+-------------------
+
+.. _new-features-34:
+
+New features
+~~~~~~~~~~~~
+
+-  ``conditional_after`` works for ``CoxPHFitter`` prediction models 😅
+
+.. _bug-fixes-40:
+
+Bug fixes
+~~~~~~~~~
+
+.. _api-changes-14:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``CoxPHFitter.baseline_cumulative_hazard_``\ ’s column is renamed
+   ``"baseline cumulative hazard"`` - previously it was
+   ``"baseline hazard"``. (Only applies if the model has no strata.)
+-  ``utils.dataframe_interpolate_at_times`` renamed to
+   ``utils.interpolate_at_times_and_return_pandas``.
+
+.. _section-58:
+
+0.22.5 - 2019-09-20
+-------------------
+
+.. _new-features-35:
+
+New features
+~~~~~~~~~~~~
+
+-  Improvements to the **repr** of models that takes into accounts
+   weights.
+-  Better support for predicting on Pandas Series
+
+.. _bug-fixes-41:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed issue where ``fit_interval_censoring`` wouldn’t accept lists.
+-  Fixed an issue with ``AalenJohansenFitter`` failing to plot
+   confidence intervals.
+
+.. _api-changes-15:
+
+API Changes
+~~~~~~~~~~~
+
+-  ``_get_initial_value`` in parametric univariate models is renamed
+   ``_create_initial_point``
+
+.. _section-59:
+
+0.22.4 - 2019-09-04
+-------------------
+
+.. _new-features-36:
+
+New features
+~~~~~~~~~~~~
+
+-  Some performance improvements to regression models.
+-  lifelines will avoid penalizing the intercept (aka bias) variables in
+   regression models.
+-  new ``utils.restricted_mean_survival_time`` that approximates the
+   RMST using numerical integration against survival functions.
+
+.. _api-changes-16:
+
+API changes
+~~~~~~~~~~~
+
+-  ``KaplanMeierFitter.survival_function_``\ ‘s’ index is no longer
+   given the name “timeline”.
+
+.. _bug-fixes-42:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed issue where ``concordance_index`` would never exit if NaNs in
+   dataset.
+
+.. _section-60:
+
+0.22.3 - 2019-08-08
+-------------------
+
+.. _new-features-37:
+
+New features
+~~~~~~~~~~~~
+
+-  model’s now expose a ``log_likelihood_`` property.
+-  new ``conditional_after`` argument on ``predict_*`` methods that make
+   prediction on censored subjects easier.
+-  new ``lifelines.utils.safe_exp`` to make ``exp`` overflows easier to
+   handle.
+-  smarter initial conditions for parametric regression models.
+-  New regression model: ``GeneralizedGammaRegressionFitter``
+
+.. _api-changes-17:
+
+API changes
+~~~~~~~~~~~
+
+-  removed ``lifelines.utils.gamma`` - use ``autograd_gamma`` library
+   instead.
+-  removed bottleneck as a dependency. It offered slight performance
+   gains only in Cox models, and only a small fraction of the API was
+   being used.
+
+.. _bug-fixes-43:
+
+Bug fixes
+~~~~~~~~~
+
+-  AFT log-likelihood ratio test was not using weights correctly.
+-  corrected (by bumping) scipy and autograd dependencies
+-  convergence is improved for most models, and many ``exp`` overflow
+   warnings have been eliminated.
+-  Fixed an error in the ``predict_percentile`` of
+   ``LogLogisticAFTFitter``. New tests have been added around this.
+
+.. _section-61:
+
+0.22.2 - 2019-07-25
+-------------------
+
+.. _new-features-38:
+
+New features
+~~~~~~~~~~~~
+
+-  lifelines is now compatible with scipy>=1.3.0
+
+.. _bug-fixes-44:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed printing error when using robust=True in regression models
+-  ``GeneralizedGammaFitter`` is more stable, maybe.
+-  lifelines was allowing old version of numpy (1.6), but this caused
+   errors when using the library. The correctly numpy has been pinned
+   (to 1.14.0+)
+
+.. _section-62:
+
+0.22.1 - 2019-07-14
+-------------------
+
+.. _new-features-39:
+
+New features
+~~~~~~~~~~~~
+
+-  New univariate model, ``GeneralizedGammaFitter``. This model contains
+   many sub-models, so it is a good model to check fits.
+-  added a warning when a time-varying dataset had instantaneous deaths.
+-  added a ``initial_point`` option in univariate parametric fitters.
+-  ``initial_point`` kwarg is present in parametric univariate fitters
+   ``.fit``
+-  ``event_table`` is now an attribute on all univariate fitters (if
+   right censoring)
+-  improvements to ``lifelines.utils.gamma``
+
+.. _api-changes-18:
+
+API changes
+~~~~~~~~~~~
+
+-  In AFT models, the column names in ``confidence_intervals_`` has
+   changed to include the alpha value.
+-  In AFT models, some column names in ``.summary`` and
+   ``.print_summary`` has changed to include the alpha value.
+-  In AFT models, some column names in ``.summary`` and
+   ``.print_summary`` includes confidence intervals for the exponential
+   of the value.
+
+.. _bug-fixes-45:
+
+Bug fixes
+~~~~~~~~~
+
+-  when using ``censors_show`` in plotting functions, the censor ticks
+   are now reactive to the estimate being shown.
+-  fixed an overflow bug in ``KaplanMeierFitter`` confidence intervals
+-  improvements in data validation for ``CoxTimeVaryingFitter``
+
+.. _section-63:
+
+0.22.0 - 2019-07-03
+-------------------
+
+.. _new-features-40:
+
+New features
+~~~~~~~~~~~~
+
+-  Ability to create custom parametric regression models by specifying
+   the cumulative hazard. This enables new and extensions of AFT models.
+-  ``percentile(p)`` method added to univariate models that solves the
+   equation ``p = S(t)`` for ``t``
+-  for parametric univariate models, the ``conditional_time_to_event_``
+   is now exact instead of an approximation.
+
+.. _api-changes-19:
+
+API changes
+~~~~~~~~~~~
+
+-  In Cox models, the attribute ``hazards_`` has been renamed to
+   ``params_``. This aligns better with the other regression models, and
+   is more clear (what is a hazard anyways?)
+-  In Cox models, a new ``hazard_ratios_`` attribute is available which
+   is the exponentiation of ``params_``.
+-  In Cox models, the column names in ``confidence_intervals_`` has
+   changed to include the alpha value.
+-  In Cox models, some column names in ``.summary`` and
+   ``.print_summary`` has changed to include the alpha value.
+-  In Cox models, some column names in ``.summary`` and
+   ``.print_summary`` includes confidence intervals for the exponential
+   of the value.
+-  Significant changes to internal AFT code.
+-  A change to how ``fit_intercept`` works in AFT models. Previously one
+   could set ``fit_intercept`` to False and not have to set
+   ``ancillary_df`` - now one must specify a DataFrame.
+
+.. _bug-fixes-46:
+
+Bug fixes
+~~~~~~~~~
+
+-  for parametric univariate models, the ``conditional_time_to_event_``
+   is now exact instead of an approximation.
+-  fixed a name error bug in ``CoxTimeVaryingFitter.plot``
+
+.. _section-64:
+
+0.21.5 - 2019-06-22
+-------------------
+
+I’m skipping 0.21.4 version because of deployment issues.
+
+.. _new-features-41:
+
+New features
+~~~~~~~~~~~~
+
+-  ``scoring_method`` now a kwarg on ``sklearn_adapter``
+
+.. _bug-fixes-47:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed an implicit import of scikit-learn. scikit-learn is an optional
+   package.
+-  fixed visual bug that misaligned x-axis ticks and at-risk counts.
+   Thanks @christopherahern!
+
+.. _section-65:
+
+0.21.3 - 2019-06-04
+-------------------
+
+.. _new-features-42:
+
+New features
+~~~~~~~~~~~~
+
+-  include in lifelines is a scikit-learn adapter so lifeline’s models
+   can be used with scikit-learn’s API. See `documentation
+   here <https://lifelines.readthedocs.io/en/latest/Compatibility%20with%20scikit-learn.html>`__.
+-  ``CoxPHFitter.plot`` now accepts a ``hazard_ratios`` (boolean)
+   parameter that will plot the hazard ratios (and CIs) instead of the
+   log-hazard ratios.
+-  ``CoxPHFitter.check_assumptions`` now accepts a ``columns`` parameter
+   to specify only checking a subset of columns.
+
+.. _bug-fixes-48:
+
+Bug fixes
+~~~~~~~~~
+
+-  ``covariates_from_event_matrix`` handle nulls better
+
+.. _section-66:
+
+0.21.2 - 2019-05-16
+-------------------
+
+.. _new-features-43:
+
+New features
+~~~~~~~~~~~~
+
+-  New regression model: ``PiecewiseExponentialRegressionFitter`` is
+   available. See blog post here:
+   https://dataorigami.net/blogs/napkin-folding/churn
+-  Regression models have a new method ``log_likelihood_ratio_test``
+   that computes, you guessed it, the log-likelihood ratio test.
+   Previously this was an internal API that is being exposed.
+
+.. _api-changes-20:
+
+API changes
+~~~~~~~~~~~
+
+-  The default behavior of the ``predict`` method on non-parametric
+   estimators (``KaplanMeierFitter``, etc.) has changed from (previous)
+   linear interpolation to (new) return last value. Linear interpolation
+   is still possible with the ``interpolate`` flag.
+-  removing ``_compute_likelihood_ratio_test`` on regression models. Use
+   ``log_likelihood_ratio_test`` now.
+
+.. _bug-fixes-49:
+
+Bug fixes
+~~~~~~~~~
+
+.. _section-67:
+
+0.21.1 - 2019-04-26
+-------------------
+
+.. _new-features-44:
+
+New features
+~~~~~~~~~~~~
+
+-  users can provided their own start and stop column names in
+   ``add_covariate_to_timeline``
+-  PiecewiseExponentialFitter now allows numpy arrays as breakpoints
+
+.. _api-changes-21:
+
+API changes
+~~~~~~~~~~~
+
+-  output of ``survival_table_from_events`` when collapsing rows to
+   intervals now removes the “aggregate” column multi-index.
+
+.. _bug-fixes-50:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed bug in CoxTimeVaryingFitter when ax is provided, thanks @j-i-l!
+
+.. _section-68:
+
+0.21.0 - 2019-04-12
+-------------------
+
+.. _new-features-45:
+
+New features
+~~~~~~~~~~~~
+
+-  ``weights`` is now a optional kwarg for parametric univariate models.
+-  all univariate and multivariate parametric models now have ability to
+   handle left, right and interval censored data (the former two being
+   special cases of the latter). Users can use the
+   ``fit_right_censoring`` (which is an alias for ``fit``),
+   ``fit_left_censoring`` and ``fit_interval_censoring``.
+-  a new interval censored dataset is available under
+   ``lifelines.datasets.load_diabetes``
+
+.. _api-changes-22:
+
+API changes
+~~~~~~~~~~~
+
+-  ``left_censorship`` on all univariate fitters has been deprecated.
+   Please use the new api ``model.fit_left_censoring(...)``.
+-  ``invert_y_axis`` in ``model.plot(...`` has been removed.
+-  ``entries`` property in multivariate parametric models has a new
+   Series name: ``entry``
+
+.. _bug-fixes-51:
+
+Bug fixes
+~~~~~~~~~
+
+-  lifelines was silently converting any NaNs in the event vector to
+   True. An error is now thrown instead.
+-  Fixed an error that didn’t let users use Numpy arrays in prediction
+   for AFT models
+
+.. _section-69:
+
+0.20.5 - 2019-04-08
+-------------------
+
+.. _new-features-46:
+
+New features
+~~~~~~~~~~~~
+
+-  performance improvements for ``print_summary``.
+
+.. _api-changes-23:
+
+API changes
+~~~~~~~~~~~
+
+-  ``utils.survival_events_from_table`` returns an integer weight vector
+   as well as durations and censoring vector.
+-  in ``AalenJohansenFitter``, the ``variance`` parameter is renamed to
+   ``variance_`` to align with the usual lifelines convention.
+
+.. _bug-fixes-52:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed an error in the ``CoxTimeVaryingFitter``\ ’s likelihood ratio
+   test when using strata.
+-  Fixed some plotting bugs with ``AalenJohansenFitter``
+
+.. _section-70:
+
+0.20.4 - 2019-03-27
+-------------------
+
+.. _new-features-47:
+
+New features
+~~~~~~~~~~~~
+
+-  left-truncation support in AFT models, using the ``entry_col`` kwarg
+   in ``fit()``
+-  ``generate_datasets.piecewise_exponential_survival_data`` for
+   generating piecewise exp. data
+-  Faster ``print_summary`` for AFT models.
+
+.. _api-changes-24:
+
+API changes
+~~~~~~~~~~~
+
+-  Pandas is now correctly pinned to >= 0.23.0. This was always the
+   case, but not specified in setup.py correctly.
+
+.. _bug-fixes-53:
+
+Bug fixes
+~~~~~~~~~
+
+-  Better handling for extremely large numbers in ``print_summary``
+-  ``PiecewiseExponentialFitter`` is available with
+   ``from lifelines import *``.
+
+.. _section-71:
+
+0.20.3 - 2019-03-23
+-------------------
+
+.. _new-features-48:
+
+New features
+~~~~~~~~~~~~
+
+-  Now ``cumulative_density_`` & ``survival_function_`` are *always*
+   present on a fitted ``KaplanMeierFitter``.
+-  New attributes/methods on ``KaplanMeierFitter``:
+   ``plot_cumulative_density()``,
+   ``confidence_interval_cumulative_density_``,
+   ``plot_survival_function`` and
+   ``confidence_interval_survival_function_``.
+
+.. _section-72:
+
+0.20.2 - 2019-03-21
+-------------------
+
+.. _new-features-49:
+
+New features
+~~~~~~~~~~~~
+
+-  Left censoring is now supported in univariate parametric models:
+   ``.fit(..., left_censorship=True)``. Examples are in the docs.
+-  new dataset: ``lifelines.datasets.load_nh4()``
+-  Univariate parametric models now include, by default, support for the
+   cumulative density function: ``.cumulative_density_``,
+   ``.confidence_interval_cumulative_density_``,
+   ``plot_cumulative_density()``, ``cumulative_density_at_times(t)``.
+-  add a ``lifelines.plotting.qq_plot`` for univariate parametric models
+   that handles censored data.
+
+.. _api-changes-25:
+
+API changes
+~~~~~~~~~~~
+
+-  ``plot_lifetimes`` no longer reverses the order when plotting. Thanks
+   @vpolimenov!
+-  The ``C`` column in ``load_lcd`` dataset is renamed to ``E``.
+
+.. _bug-fixes-54:
+
+Bug fixes
+~~~~~~~~~
+
+-  fixed a naming error in ``KaplanMeierFitter`` when
+   ``left_censorship`` was set to True, ``plot_cumulative_density_()``
+   is now ``plot_cumulative_density()``.
+-  added some error handling when passing in timedeltas. Ideally, users
+   don’t pass in timedeltas, as the scale is ambiguous. However, the
+   error message before was not obvious, so we do some conversion, warn
+   the user, and pass it through.
+-  ``qth_survival_times`` for a truncated CDF would return ``np.inf`` if
+   the q parameter was below the truncation limit. This should have been
+   ``-np.inf``
+
+.. _section-73:
+
+0.20.1 - 2019-03-16
+-------------------
+
+-  Some performance improvements to ``CoxPHFitter`` (about 30%). I know
+   it may seem silly, but we are now about the same or slightly faster
+   than the Cox model in R’s ``survival`` package (for some testing
+   datasets and some configurations). This is a big deal, because 1)
+   lifelines does more error checking prior, 2) R’s cox model is written
+   in C, and we are still pure Python/NumPy, 3) R’s cox model has
+   decades of development.
+-  suppressed unimportant warnings
+
+.. _api-changes-26:
+
+API changes
+~~~~~~~~~~~
+
+-  Previously, lifelines *always* added a 0 row to
+   ``cph.baseline_hazard_``, even if there were no event at this time.
+   This is no longer the case. A 0 will still be added if there is a
+   duration (observed or not) at 0 occurs however.
+
+.. _section-74:
+
+0.20.0 - 2019-03-05
+-------------------
+
+-  Starting with 0.20.0, only Python3 will be supported. Over 75% of
+   recent installs where Py3.
+-  Updated minimum dependencies, specifically Matplotlib and Pandas.
+
+.. _new-features-50:
+
+New features
+~~~~~~~~~~~~
+
+-  smarter initialization for AFT models which should improve
+   convergence.
+
+.. _api-changes-27:
+
+API changes
+~~~~~~~~~~~
+
+-  ``initial_beta`` in Cox model’s ``.fit`` is now ``initial_point``.
+-  ``initial_point`` is now available in AFT models and
+   ``CoxTimeVaryingFitter``
+-  the DataFrame ``confidence_intervals_`` for univariate models is
+   transposed now (previous parameters where columns, now parameters are
+   rows).
+
+.. _bug-fixes-55:
+
+Bug fixes
+~~~~~~~~~
+
+-  Fixed a bug with plotting and ``check_assumptions``.
+
+.. _section-75:
+
+0.19.5 - 2019-02-26
+-------------------
+
+.. _new-features-51:
+
+New features
+~~~~~~~~~~~~
+
+-  ``plot_covariate_group`` can accept multiple covariates to plot. This
+   is useful for columns that have implicit correlation like polynomial
+   features or categorical variables.
+-  Convergence improvements for AFT models.
+
+.. _section-76:
+
+0.19.4 - 2019-02-25
+-------------------
+
+.. _bug-fixes-56:
+
+Bug fixes
+~~~~~~~~~
+
+-  remove some bad print statements in ``CoxPHFitter``.
+
+.. _section-77:
+
+0.19.3 - 2019-02-25
+-------------------
+
+.. _new-features-52:
+
+New features
+~~~~~~~~~~~~
+
+-  new AFT models: ``LogNormalAFTFitter`` and ``LogLogisticAFTFitter``.
+-  AFT models now accept a ``weights_col`` argument to ``fit``.
+-  Robust errors (sandwich errors) are now available in AFT models using
+   the ``robust=True`` kwarg in ``fit``.
+-  Performance increase to ``print_summary`` in the ``CoxPHFitter`` and
+   ``CoxTimeVaryingFitter`` model.
+
+.. _section-78:
+
+0.19.2 - 2019-02-22
+-------------------
+
+.. _new-features-53:
+
+New features
+~~~~~~~~~~~~
+
+-  ``ParametricUnivariateFitters``, like ``WeibullFitter``, have
+   smoothed plots when plotting (vs stepped plots)
+
+.. _bug-fixes-57:
+
+Bug fixes
+~~~~~~~~~
+
+-  The ``ExponentialFitter`` log likelihood *value* was incorrect -
+   inference was correct however.
+-  Univariate fitters are more flexiable and can allow 2-d and
+   DataFrames as inputs.
+
+.. _section-79:
+
+0.19.1 - 2019-02-21
+-------------------
+
+.. _new-features-54:
+
+New features
+~~~~~~~~~~~~
+
+-  improved stability of ``LogNormalFitter``
+-  Matplotlib for Python3 users are not longer forced to use 2.x.
+
+.. _api-changes-28:
+
+API changes
+~~~~~~~~~~~
+
+-  **Important**: we changed the parameterization of the
+   ``PiecewiseExponential`` to the same as ``ExponentialFitter`` (from
+   ``\lambda * t`` to ``t / \lambda``).
+
+.. _section-80:
+
+0.19.0 - 2019-02-20
+-------------------
+
+.. _new-features-55:
+
+New features
+~~~~~~~~~~~~
+
+-  New regression model ``WeibullAFTFitter`` for fitting accelerated
+   failure time models. Docs have been added to our
+   `documentation <https://lifelines.readthedocs.io/>`__ about how to
+   use ``WeibullAFTFitter`` (spoiler: it’s API is similar to the other
+   regression models) and how to interpret the output.
+-  ``CoxPHFitter`` performance improvements (about 10%)
+-  ``CoxTimeVaryingFitter`` performance improvements (about 10%)
+
+.. _api-changes-29:
+
+API changes
+~~~~~~~~~~~
+
+-  **Important**: we changed the ``.hazards_`` and ``.standard_errors_``
+   on Cox models to be pandas Series (instead of Dataframes). This felt
+   like a more natural representation of them. You may need to update
+   your code to reflect this. See notes here:
+   https://github.com/CamDavidsonPilon/lifelines/issues/636
+-  **Important**: we changed the ``.confidence_intervals_`` on Cox
+   models to be transposed. This felt like a more natural representation
+   of them. You may need to update your code to reflect this. See notes
+   here: https://github.com/CamDavidsonPilon/lifelines/issues/636
+-  **Important**: we changed the parameterization of the
+   ``WeibullFitter`` and ``ExponentialFitter`` from ``\lambda * t`` to
+   ``t / \lambda``. This was for a few reasons: 1) it is a more common
+   parameterization in literature, 2) it helps in convergence.
+-  **Important**: in models where we add an intercept (currently only
+   ``AalenAdditiveModel``), the name of the added column has been
+   changed from ``baseline`` to ``_intercept``
+-  **Important**: the meaning of ``alpha`` in all fitters has changed to
+   be the standard interpretation of alpha in confidence intervals. That
+   means that the *default* for alpha is set to 0.05 in the latest
+   lifelines, instead of 0.95 in previous versions.
+
+.. _bug-fixes-58:
+
+Bug Fixes
+~~~~~~~~~
+
+-  Fixed a bug in the ``_log_likelihood_`` property of
+   ``ParametericUnivariateFitter`` models. It was showing the “average”
+   log-likelihood (i.e. scaled by 1/n) instead of the total. It now
+   displays the total.
+-  In model ``print_summary``\ s, correct a label erroring. Instead of
+   “Likelihood test”, it should have read “Log-likelihood test”.
+-  Fixed a bug that was too frequently rejecting the dtype of ``event``
+   columns.
+-  Fixed a calculation bug in the concordance index for stratified Cox
+   models. Thanks @airanmehr!
+-  Fixed some Pandas <0.24 bugs.
+
+.. _section-81:
+
+0.18.6 - 2019-02-13
+-------------------
+
+-  some improvements to the output of ``check_assumptions``.
+   ``show_plots`` is turned to ``False`` by default now. It only shows
+   ``rank`` and ``km`` p-values now.
+-  some performance improvements to ``qth_survival_time``.
+
+.. _section-82:
+
+0.18.5 - 2019-02-11
+-------------------
+
+-  added new plotting methods to parametric univariate models:
+   ``plot_survival_function``, ``plot_hazard`` and
+   ``plot_cumulative_hazard``. The last one is an alias for ``plot``.
+-  added new properties to parametric univarite models:
+   ``confidence_interval_survival_function_``,
+   ``confidence_interval_hazard_``,
+   ``confidence_interval_cumulative_hazard_``. The last one is an alias
+   for ``confidence_interval_``.
+-  Fixed some overflow issues with ``AalenJohansenFitter``\ ’s variance
+   calculations when using large datasets.
+-  Fixed an edgecase in ``AalenJohansenFitter`` that causing some
+   datasets with to be jittered too often.
+-  Add a new kwarg to ``AalenJohansenFitter``, ``calculate_variance``
+   that can be used to turn off variance calculations since this can
+   take a long time for large datasets. Thanks @pzivich!
+
+.. _section-83:
+
+0.18.4 - 2019-02-10
+-------------------
+
+-  fixed confidence intervals in cumulative hazards for parametric
+   univarite models. They were previously serverly depressed.
+-  adding left-truncation support to parametric univarite models with
+   the ``entry`` kwarg in ``.fit``
+
+.. _section-84:
+
+0.18.3 - 2019-02-07
+-------------------
+
+-  Some performance improvements to parametric univariate models.
+-  Suppressing some irrelevant NumPy and autograd warnings, so lifeline
+   warnings are more noticeable.
+-  Improved some warning and error messages.
+
+.. _section-85:
+
+0.18.2 - 2019-02-05
+-------------------
+
+-  New univariate fitter ``PiecewiseExponentialFitter`` for creating a
+   stepwise hazard model. See docs online.
+-  Ability to create novel parametric univariate models using the new
+   ``ParametericUnivariateFitter`` super class. See docs online for how
+   to do this.
+-  Unfortunately, parametric univariate fitters are not serializable
+   with ``pickle``. The library ``dill`` is still useable.
+-  Complete overhaul of all internals for parametric univariate fitters.
+   Moved them all (most) to use ``autograd``.
+-  ``LogNormalFitter`` no longer models ``log_sigma``.
+
+.. _section-86:
+
+0.18.1 - 2019-02-02
+-------------------
+
+-  bug fixes in ``LogNormalFitter`` variance estimates
+-  improve convergence of ``LogNormalFitter``. We now model the log of
+   sigma internally, but still expose sigma externally.
+-  use the ``autograd`` lib to help with gradients.
+-  New ``LogLogisticFitter`` univariate fitter available.
+
+.. _section-87:
+
+0.18.0 - 2019-01-31
+-------------------
+
+-  ``LogNormalFitter`` is a new univariate fitter you can use.
+-  ``WeibullFitter`` now correctly returns the confidence intervals
+   (previously returned only NaNs)
+-  ``WeibullFitter.print_summary()`` displays p-values associated with
+   its parameters not equal to 1.0 - previously this was (implicitly)
+   comparing against 0, which is trivially always true (the parameters
+   must be greater than 0)
+-  ``ExponentialFitter.print_summary()`` displays p-values associated
+   with its parameters not equal to 1.0 - previously this was
+   (implicitly) comparing against 0, which is trivially always true (the
+   parameters must be greater than 0)
+-  ``ExponentialFitter.plot`` now displays the cumulative hazard,
+   instead of the survival function. This is to make it easier to
+   compare to ``WeibullFitter`` and ``LogNormalFitter``
+-  Univariate fitters’ ``cumulative_hazard_at_times``,
+   ``hazard_at_times``, ``survival_function_at_times`` return pandas
+   Series now (use to be numpy arrays)
+-  remove ``alpha`` keyword from all statistical functions. This was
+   never being used.
+-  Gone are asterisks and dots in ``print_summary`` functions that
+   represent signficance thresholds.
+-  In models’ ``summary`` (including ``print_summary``), the ``log(p)``
+   term has changed to ``-log2(p)``. This is known as the s-value. See
+   https://lesslikely.com/statistics/s-values/
+-  introduce new statistical tests between univariate datasets:
+   ``survival_difference_at_fixed_point_in_time_test``,…
+-  new warning message when Cox models detects possible non-unique
+   solutions to maximum likelihood.
+-  Generally: clean up lifelines exception handling. Ex: catch
+   ``LinAlgError: Matrix is singular.`` and report back to the user
+   advice.
+
+.. _section-88:
+
+0.17.5 - 2019-01-25
+-------------------
+
+-  more bugs in ``plot_covariate_groups`` fixed when using non-numeric
+   strata.
+
+.. _section-89:
+
+0.17.4 -2019-01-25
+------------------
+
+-  Fix bug in ``plot_covariate_groups`` that wasn’t allowing for strata
+   to be used.
+-  change name of ``multicenter_aids_cohort_study`` to
+   ``load_multicenter_aids_cohort_study``
+-  ``groups`` is now called ``values`` in
+   ``CoxPHFitter.plot_covariate_groups``
+
+.. _section-90:
+
+0.17.3 - 2019-01-24
+-------------------
+
+-  Fix in ``compute_residuals`` when using ``schoenfeld`` and the
+   minimum duration has only censored subjects.
+
+.. _section-91:
+
+0.17.2 2019-01-22
+-----------------
+
+-  Another round of serious performance improvements for the Cox models.
+   Up to 2x faster for CoxPHFitter and CoxTimeVaryingFitter. This was
+   mostly the result of using NumPy��s ``einsum`` to simplify a previous
+   ``for`` loop. The downside is the code is more esoteric now. I’ve
+   added comments as necessary though 🤞
+
+.. _section-92:
+
+0.17.1 - 2019-01-20
+-------------------
+
+-  adding bottleneck as a dependency. This library is highly-recommended
+   by Pandas, and in lifelines we see some nice performance improvements
+   with it too. (~15% for ``CoxPHFitter``)
+-  There was a small bug in ``CoxPHFitter`` when using ``batch_mode``
+   that was causing coefficients to deviate from their MLE value. This
+   bug eluded tests, which means that it’s discrepancy was less than
+   0.0001 difference. It’s fixed now, and even more accurate tests are
+   added.
+-  Faster ``CoxPHFitter._compute_likelihood_ratio_test()``
+-  Fixes a Pandas performance warning in ``CoxTimeVaryingFitter``.
+-  Performances improvements to ``CoxTimeVaryingFitter``.
+
+.. _section-93:
+
+0.17.0 - 2019-01-11
+-------------------
+
+-  corrected behaviour in ``CoxPHFitter`` where ``score_`` was not being
+   refreshed on every new ``fit``.
+-  Reimplentation of ``AalenAdditiveFitter``. There were significant
+   changes to it:
+
+   -  implementation is at least 10x faster, and possibly up to 100x
+      faster for some datasets.
+   -  memory consumption is way down
+   -  removed the time-varying component from ``AalenAdditiveFitter``.
+      This will return in a future release.
+   -  new ``print_summary``
+   -  ``weights_col`` is added
+   -  ``nn_cumulative_hazard`` is removed (may add back)
+
+-  some plotting improvements to ``plotting.plot_lifetimes``
+
+.. _section-94:
+
+0.16.3 - 2019-01-03
+-------------------
+
+-  More ``CoxPHFitter`` performance improvements. Up to a 40% reduction
+   vs 0.16.2 for some datasets.
+
+.. _section-95:
+
+0.16.2 - 2019-01-02
+-------------------
+
+-  Fixed ``CoxTimeVaryingFitter`` to allow more than one variable to be
+   stratafied
+-  Significant performance improvements for ``CoxPHFitter`` with dataset
+   has lots of duplicate times. See
+   https://github.com/CamDavidsonPilon/lifelines/issues/591
+
+.. _section-96:
+
+0.16.1 - 2019-01-01
+-------------------
+
+-  Fixed py2 division error in ``concordance`` method.
+
+.. _section-97:
+
+0.16.0 - 2019-01-01
+-------------------
+
+-  Drop Python 3.4 support.
+-  introduction of residual calculations in
+   ``CoxPHFitter.compute_residuals``. Residuals include “schoenfeld”,
+   “score”, “delta_beta”, “deviance”, “martingale”, and
+   “scaled_schoenfeld”.
+-  removes ``estimation`` namespace for fitters. Should be using
+   ``from lifelines import xFitter`` now. Thanks @usmanatron
+-  removes ``predict_log_hazard_relative_to_mean`` from Cox model.
+   Thanks @usmanatron
+-  ``StatisticalResult`` has be generalized to allow for multiple
+   results (ex: from pairwise comparisons). This means a slightly
+   changed API that is mostly backwards compatible. See doc string for
+   how to use it.
+-  ``statistics.pairwise_logrank_test`` now returns a
+   ``StatisticalResult`` object instead of a nasty NxN DataFrame 💗
+-  Display log(p-values) as well as p-values in ``print_summary``. Also,
+   p-values below thresholds will be truncated. The original p-values are
+   still recoverable using ``.summary``.
+-  Floats ``print_summary`` is now displayed to 2 decimal points. This
+   can be changed using the ``decimal`` kwarg.
+-  removed ``standardized`` from ``Cox`` model plotting. It was
+   confusing.
+-  visual improvements to Cox models ``.plot``
+-  ``print_summary`` methods accepts kwargs to also be displayed.
+-  ``CoxPHFitter`` has a new human-readable method,
+   ``check_assumptions``, to check the assumptions of your Cox
+   proportional hazard model.
+-  A new helper util to “expand” static datasets into long-form:
+   ``lifelines.utils.to_episodic_format``.
+-  ``CoxTimeVaryingFitter`` now accepts ``strata``.
+
+.. _section-98:
+
+0.15.4
+------
+
+-  bug fix for the Cox model likelihood ratio test when using
+   non-trivial weights.
+
+.. _section-99:
+
+0.15.3 - 2018-12-18
+-------------------
+
+-  Only allow matplotlib less than 3.0.
+
+.. _section-100:
+
+0.15.2 - 2018-11-23
+-------------------
+
+-  API changes to ``plotting.plot_lifetimes``
+-  ``cluster_col`` and ``strata`` can be used together in
+   ``CoxPHFitter``
+-  removed ``entry`` from ``ExponentialFitter`` and ``WeibullFitter`` as
+   it was doing nothing.
+
+.. _section-101:
+
+0.15.1 - 2018-11-23
+-------------------
+
+-  Bug fixes for v0.15.0
+-  Raise NotImplementedError if the ``robust`` flag is used in
+   ``CoxTimeVaryingFitter`` - that’s not ready yet.
+
+.. _section-102:
+
+0.15.0 - 2018-11-22
+-------------------
+
+-  adding ``robust`` params to ``CoxPHFitter``\ ’s ``fit``. This enables
+   atleast i) using non-integer weights in the model (these could be
+   sampling weights like IPTW), and ii) mis-specified models (ex:
+   non-proportional hazards). Under the hood it’s a sandwich estimator.
+   This does not handle ties, so if there are high number of ties,
+   results may significantly differ from other software.
+-  ``standard_errors_`` is now a property on fitted ``CoxPHFitter``
+   which describes the standard errors of the coefficients.
+-  ``variance_matrix_`` is now a property on fitted ``CoxPHFitter``
+   which describes the variance matrix of the coefficients.
+-  new criteria for convergence of ``CoxPHFitter`` and
+   ``CoxTimeVaryingFitter`` called the Newton-decrement. Tests show it
+   is as accurate (w.r.t to previous coefficients) and typically shaves
+   off a single step, resulting in generally faster convergence. See
+   https://www.cs.cmu.edu/~pradeepr/convexopt/Lecture_Slides/Newton_methods.pdf.
+   Details about the Newton-decrement are added to the ``show_progress``
+   statements.
+-  Minimum support for scipy is 1.0
+-  Convergence errors in models that use Newton-Rhapson methods now
+   throw a ``ConvergenceError``, instead of a ``ValueError`` (the former
+   is a subclass of the latter, however).
+-  ``AalenAdditiveModel`` raises ``ConvergenceWarning`` instead of
+   printing a warning.
+-  ``KaplanMeierFitter`` now has a cumulative plot option. Example
+   ``kmf.plot(invert_y_axis=True)``
+-  a ``weights_col`` option has been added to ``CoxTimeVaryingFitter``
+   that allows for time-varying weights.
+-  ``WeibullFitter`` has a new ``show_progress`` param and additional
+   information if the convergence fails.
+-  ``CoxPHFitter``, ``ExponentialFitter``, ``WeibullFitter`` and
+   ``CoxTimeVaryFitter`` method ``print_summary`` is updated with new
+   fields.
+-  ``WeibullFitter`` has renamed the incorrect ``_jacobian`` to
+   ``_hessian_``.
+-  ``variance_matrix_`` is now a property on fitted ``WeibullFitter``
+   which describes the variance matrix of the parameters.
+-  The default ``WeibullFitter().timeline`` has changed from integers
+   between the min and max duration to *n* floats between the max and
+   min durations, where *n* is the number of observations.
+-  Performance improvements for ``CoxPHFitter`` (~20% faster)
+-  Performance improvements for ``CoxTimeVaryingFitter`` (~100% faster)
+-  In Python3, Univariate models are now serialisable with ``pickle``.
+   Thanks @dwilson1988 for the contribution. For Python2, ``dill`` is
+   still the preferred method.
+-  ``baseline_cumulative_hazard_`` (and derivatives of that) on
+   ``CoxPHFitter`` now correctly incorporate the ``weights_col``.
+-  Fixed a bug in ``KaplanMeierFitter`` when late entry times lined up
+   with death events. Thanks @pzivich
+-  Adding ``cluster_col`` argument to ``CoxPHFitter`` so users can
+   specify groups of subjects/rows that may be correlated.
+-  Shifting the “signficance codes” for p-values down an order of
+   magnitude. (Example, p-values between 0.1 and 0.05 are not noted at
+   all and p-values between 0.05 and 0.1 are noted with ``.``, etc.).
+   This deviates with how they are presented in other software. There is
+   an argument to be made to remove p-values from lifelines altogether
+   (*become the changes you want to see in the world* lol), but I worry
+   that people could compute the p-values by hand incorrectly, a worse
+   outcome I think. So, this is my stance. P-values between 0.1 and 0.05
+   offer *very* little information, so they are removed. There is a
+   growing movement in statistics to shift “significant” findings to
+   p-values less than 0.01 anyways.
+-  New fitter for cumulative incidence of multiple risks
+   ``AalenJohansenFitter``. Thanks @pzivich! See “Methodologic Issues
+   When Estimating Risks in Pharmacoepidemiology” for a nice overview of
+   the model.
+
+.. _section-103:
+
+0.14.6 - 2018-07-02
+-------------------
+
+-  fix for n > 2 groups in ``multivariate_logrank_test`` (again).
+-  fix bug for when ``event_observed`` column was not boolean.
+
+.. _section-104:
+
+0.14.5 - 2018-06-29
+-------------------
+
+-  fix for n > 2 groups in ``multivariate_logrank_test``
+-  fix weights in KaplanMeierFitter when using a pandas Series.
+
+.. _section-105:
+
+0.14.4 - 2018-06-14
+-------------------
+
+-  Adds ``baseline_cumulative_hazard_`` and ``baseline_survival_`` to
+   ``CoxTimeVaryingFitter``. Because of this, new prediction methods are
+   available.
+-  fixed a bug in ``add_covariate_to_timeline`` when using
+   ``cumulative_sum`` with multiple columns.
+-  Added ``Likelihood ratio test`` to ``CoxPHFitter.print_summary`` and
+   ``CoxTimeVaryingFitter.print_summary``
+-  New checks in ``CoxTimeVaryingFitter`` that check for immediate
+   deaths and redundant rows.
+-  New ``delay`` parameter in ``add_covariate_to_timeline``
+-  removed ``two_sided_z_test`` from ``statistics``
+
+.. _section-106:
+
+0.14.3 - 2018-05-24
+-------------------
+
+-  fixes a bug when subtracting or dividing two ``UnivariateFitters``
+   with labels.
+-  fixes an import error with using ``CoxTimeVaryingFitter`` predict
+   methods.
+-  adds a ``column`` argument to ``CoxTimeVaryingFitter`` and
+   ``CoxPHFitter`` ``plot`` method to plot only a subset of columns.
+
+.. _section-107:
+
+0.14.2 - 2018-05-18
+-------------------
+
+-  some quality of life improvements for working with
+   ``CoxTimeVaryingFitter`` including new ``predict_`` methods.
+
+.. _section-108:
+
+0.14.1 - 2018-04-01
+-------------------
+
+-  fixed bug with using weights and strata in ``CoxPHFitter``
+-  fixed bug in using non-integer weights in ``KaplanMeierFitter``
+-  Performance optimizations in ``CoxPHFitter`` for up to 40% faster
+   completion of ``fit``.
+
+   -  even smarter ``step_size`` calculations for iterative
+      optimizations.
+   -  simple code optimizations & cleanup in specific hot spots.
+
+-  Performance optimizations in ``AalenAdditiveFitter`` for up to 50%
+   faster completion of ``fit`` for large dataframes, and up to 10%
+   faster for small dataframes.
+
+.. _section-109:
+
+0.14.0 - 2018-03-03
+-------------------
+
+-  adding ``plot_covariate_groups`` to ``CoxPHFitter`` to visualize what
+   happens to survival as we vary a covariate, all else being equal.
+-  ``utils`` functions like ``qth_survival_times`` and
+   ``median_survival_times`` now return the transpose of the DataFrame
+   compared to previous version of lifelines. The reason for this is
+   that we often treat survival curves as columns in DataFrames, and
+   functions of the survival curve as index (ex:
+   KaplanMeierFitter.survival_function\_ returns a survival curve *at*
+   time *t*).
+-  ``KaplanMeierFitter.fit`` and ``NelsonAalenFitter.fit`` accept a
+   ``weights`` vector that can be used for pre-aggregated datasets. See
+   this
+   `issue <https://github.com/CamDavidsonPilon/lifelines/issues/396>`__.
+-  Convergence errors now return a custom ``ConvergenceWarning`` instead
+   of a ``RuntimeWarning``
+-  New checks for complete separation in the dataset for regressions.
+
+.. _section-110:
+
+0.13.0 - 2017-12-22
+-------------------
+
+-  removes ``is_significant`` and ``test_result`` from
+   ``StatisticalResult``. Users can instead choose their significance
+   level by comparing to ``p_value``. The string representation of this
+   class has changed aswell.
+-  ``CoxPHFitter`` and ``AalenAdditiveFitter`` now have a ``score_``
+   property that is the concordance-index of the dataset to the fitted
+   model.
+-  ``CoxPHFitter`` and ``AalenAdditiveFitter`` no longer have the
+   ``data`` property. It was an *almost* duplicate of the training data,
+   but was causing the model to be very large when serialized.
+-  Implements a new fitter ``CoxTimeVaryingFitter`` available under the
+   ``lifelines`` namespace. This model implements the Cox model for
+   time-varying covariates.
+-  Utils for creating time varying datasets available in ``utils``.
+-  less noisy check for complete separation.
+-  removed ``datasets`` namespace from the main ``lifelines`` namespace
+-  ``CoxPHFitter`` has a slightly more intelligent (barely…) way to pick
+   a step size, so convergence should generally be faster.
+-  ``CoxPHFitter.fit`` now has accepts a ``weight_col`` kwarg so one can
+   pass in weights per observation. This is very useful if you have many
+   subjects, and the space of covariates is not large. Thus you can
+   group the same subjects together and give that observation a weight
+   equal to the count. Altogether, this means a much faster regression.
+
+.. _section-111:
+
+0.12.0
+------
+
+-  removes ``include_likelihood`` from ``CoxPHFitter.fit`` - it was not
+   slowing things down much (empirically), and often I wanted it for
+   debugging (I suppose others do too). It’s also another exit
+   condition, so we many exit from the NR iterations faster.
+-  added ``step_size`` param to ``CoxPHFitter.fit`` - the default is
+   good, but for extremely large or small datasets this may want to be
+   set manually.
+-  added a warning to ``CoxPHFitter`` to check for complete separation:
+   https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/
+-  Additional functionality to ``utils.survival_table_from_events`` to
+   bin the index to make the resulting table more readable.
+
+.. _section-112:
+
+0.11.3
+------
+
+-  No longer support matplotlib 1.X
+-  Adding ``times`` argument to ``CoxPHFitter``\ ’s
+   ``predict_survival_function`` and ``predict_cumulative_hazard`` to
+   predict the estimates at, instead uses the default times of
+   observation or censorship.
+-  More accurate prediction methods parametrics univariate models.
+
+.. _section-113:
+
+0.11.2
+------
+
+-  Changing license to valilla MIT.
+-  Speed up ``NelsonAalenFitter.fit`` considerably.
+
+.. _section-114:
+
+0.11.1 - 2017-06-22
+-------------------
+
+-  Python3 fix for ``CoxPHFitter.plot``.
+
+.. _section-115:
+
+0.11.0 - 2017-06-21
+-------------------
+
+-  fixes regression in ``KaplanMeierFitter.plot`` when using Seaborn and
+   lifelines.
+-  introduce a new ``.plot`` function to a fitted ``CoxPHFitter``
+   instance. This plots the hazard coefficients and their confidence
+   intervals.
+-  in all plot methods, the ``ix`` kwarg has been deprecated in favour
+   of a new ``loc`` kwarg. This is to align with Pandas deprecating
+   ``ix``
+
+.. _section-116:
+
+0.10.1 - 2017-06-05
+-------------------
+
+-  fix in internal normalization for ``CoxPHFitter`` predict methods.
+
+.. _section-117:
+
+0.10.0
+------
+
+-  corrected bug that was returning the wrong baseline survival and
+   hazard values in ``CoxPHFitter`` when ``normalize=True``.
+-  removed ``normalize`` kwarg in ``CoxPHFitter``. This was causing lots
+   of confusion for users, and added code complexity. It’s really nice
+   to be able to remove it.
+-  correcting column name in ``CoxPHFitter.baseline_survival_``
+-  ``CoxPHFitter.baseline_cumulative_hazard_`` is always centered, to
+   mimic R’s ``basehaz`` API.
+-  new ``predict_log_partial_hazards`` to ``CoxPHFitter``
+
+.. _section-118:
+
+0.9.4
+-----
+
+-  adding ``plot_loglogs`` to ``KaplanMeierFitter``
+-  added a (correct) check to see if some columns in a dataset will
+   cause convergence problems.
+-  removing ``flat`` argument in ``plot`` methods. It was causing
+   confusion. To replicate it, one can set ``ci_force_lines=True`` and
+   ``show_censors=True``.
+-  adding ``strata`` keyword argument to ``CoxPHFitter`` on
+   initialization (ex: ``CoxPHFitter(strata=['v1', 'v2'])``. Why?
+   Fitters initialized with ``strata`` can now be passed into
+   ``k_fold_cross_validation``, plus it makes unit testing ``strata``
+   fitters easier.
+-  If using ``strata`` in ``CoxPHFitter``, access to strata specific
+   baseline hazards and survival functions are available (previously it
+   was a blended valie). Prediction also uses the specific baseline
+   hazards/survivals.
+-  performance improvements in ``CoxPHFitter`` - should see at least a
+   10% speed improvement in ``fit``.
+
+.. _section-119:
+
+0.9.2
+-----
+
+-  deprecates Pandas versions before 0.18.
+-  throw an error if no admissible pairs in the c-index calculation.
+   Previously a NaN was returned.
+
+.. _section-120:
+
+0.9.1
+-----
+
+-  add two summary functions to Weibull and Exponential fitter, solves
+   #224
+
+.. _section-121:
+
+0.9.0
+-----
+
+-  new prediction function in ``CoxPHFitter``,
+   ``predict_log_hazard_relative_to_mean``, that mimics what R’s
+   ``predict.coxph`` does.
+-  removing the ``predict`` method in CoxPHFitter and
+   AalenAdditiveFitter. This is because the choice of ``predict_median``
+   as a default was causing too much confusion, and no other natual
+   choice as a default was available. All other ``predict_`` methods
+   remain.
+-  Default predict method in ``k_fold_cross_validation`` is now
+   ``predict_expectation``
+
+.. _section-122:
+
+0.8.1 - 2015-08-01
+------------------
+
+-  supports matplotlib 1.5.
+-  introduction of a param ``nn_cumulative_hazards`` in
+   AalenAdditiveModel’s ``__init__`` (default True). This parameter will
+   truncate all non-negative cumulative hazards in prediction methods to
+   0.
+-  bug fixes including:
+
+   -  fixed issue where the while loop in ``_newton_rhaphson`` would
+      break too early causing a variable not to be set properly.
+   -  scaling of smooth hazards in NelsonAalenFitter was off by a factor
+      of 0.5.
+
+.. _section-123:
+
+0.8.0
+-----
+
+-  reorganized lifelines directories:
+
+   -  moved test files out of main directory.
+   -  moved ``utils.py`` into it’s own directory.
+   -  moved all estimators ``fitters`` directory.
+
+-  added a ``at_risk`` column to the output of
+   ``group_survival_table_from_events`` and
+   ``survival_table_from_events``
+-  added sample size and power calculations for statistical tests. See
+   ``lifeline.statistics. sample_size_necessary_under_cph`` and
+   ``lifelines.statistics. power_under_cph``.
+-  fixed a bug when using KaplanMeierFitter for left-censored data.
+
+.. _section-124:
+
+0.7.1
+-----
+
+-  addition of a l2 ``penalizer`` to ``CoxPHFitter``.
+-  dropped Fortran implementation of efficient Python version. Lifelines
+   is pure python once again!
+-  addition of ``strata`` keyword argument to ``CoxPHFitter`` to allow
+   for stratification of a single or set of categorical variables in
+   your dataset.
+-  ``datetimes_to_durations`` now accepts a list as ``na_values``, so
+   multiple values can be checked.
+-  fixed a bug in ``datetimes_to_durations`` where ``fill_date`` was not
+   properly being applied.
+-  Changed warning in ``datetimes_to_durations`` to be correct.
+-  refactor each fitter into it’s own submodule. For now, the tests are
+   still in the same file. This will also *not* break the API.
+
+.. _section-125:
+
+0.7.0 - 2015-03-01
+------------------
+
+-  allow for multiple fitters to be passed into
+   ``k_fold_cross_validation``.
+-  statistical tests in ``lifelines.statistics``. now return a
+   ``StatisticalResult`` object with properties like ``p_value``,
+   ``test_results``, and ``summary``.
+-  fixed a bug in how log-rank statistical tests are performed. The
+   covariance matrix was not being correctly calculated. This resulted
+   in slightly different p-values.
+-  ``WeibullFitter``, ``ExponentialFitter``, ``KaplanMeierFitter`` and
+   ``BreslowFlemingHarringtonFitter`` all have a
+   ``conditional_time_to_event_`` property that measures the median
+   duration remaining until the death event, given survival up until
+   time t.
+
+.. _section-126:
+
+0.6.1
+-----
+
+-  addition of ``median_`` property to ``WeibullFitter`` and
+   ``ExponentialFitter``.
+-  ``WeibullFitter`` and ``ExponentialFitter`` will use integer
+   timelines instead of float provided by ``linspace``. This is so if
+   your work is to sum up the survival function (for expected values or
+   something similar), it’s more difficult to make a mistake.
+
+.. _section-127:
+
+0.6.0 - 2015-02-04
+------------------
+
+-  Inclusion of the univariate fitters ``WeibullFitter`` and
+   ``ExponentialFitter``.
+-  Removing ``BayesianFitter`` from lifelines.
+-  Added new penalization scheme to AalenAdditiveFitter. You can now add
+   a smoothing penalizer that will try to keep subsequent values of a
+   hazard curve close together. The penalizing coefficient is
+   ``smoothing_penalizer``.
+-  Changed ``penalizer`` keyword arg to ``coef_penalizer`` in
+   AalenAdditiveFitter.
+-  new ``ridge_regression`` function in ``utils.py`` to perform linear
+   regression with l2 penalizer terms.
+-  Matplotlib is no longer a mandatory dependency.
+-  ``.predict(time)`` method on univariate fitters can now accept a
+   scalar (and returns a scalar) and an iterable (and returns a numpy
+   array)
+-  In ``KaplanMeierFitter``, ``epsilon`` has been renamed to
+   ``precision``.
+
+.. _section-128:
+
+0.5.1 - 2014-12-24
+------------------
+
+-  New API for ``CoxPHFitter`` and ``AalenAdditiveFitter``: the default
+   arguments for ``event_col`` and ``duration_col``. ``duration_col`` is
+   now mandatory, and ``event_col`` now accepts a column, or by default,
+   ``None``, which assumes all events are observed (non-censored).
+-  Fix statistical tests.
+-  Allow negative durations in Fitters.
+-  New API in ``survival_table_from_events``: ``min_observations`` is
+   replaced by ``birth_times`` (default ``None``).
+-  New API in ``CoxPHFitter`` for summary: ``summary`` will return a
+   dataframe with statistics, ``print_summary()`` will print the
+   dataframe (plus some other statistics) in a pretty manner.
+-  Adding “At Risk” counts option to univariate fitter ``plot`` methods,
+   ``.plot(at_risk_counts=True)``, and the function
+   ``lifelines.plotting.add_at_risk_counts``.
+-  Fix bug Epanechnikov kernel.
+
+.. _section-129:
+
+0.5.0 - 2014-12-07
+------------------
+
+-  move testing to py.test
+-  refactor tests into smaller files
+-  make
+   ``test_pairwise_logrank_test_with_identical_data_returns_inconclusive``
+   a better test
+-  add test for summary()
+-  Alternate metrics can be used for ``k_fold_cross_validation``.
+
+.. _section-130:
+
+0.4.4 - 2014-11-27
+------------------
+
+-  Lots of improvements to numerical stability (but something things
+   still need work)
+-  Additions to ``summary`` in CoxPHFitter.
+-  Make all prediction methods output a DataFrame
+-  Fixes bug in 1-d input not returning in CoxPHFitter
+-  Lots of new tests.
+
+.. _section-131:
+
+0.4.3 - 2014-07-23
+------------------
+
+-  refactoring of ``qth_survival_times``: it can now accept an iterable
+   (or a scalar still) of probabilities in the q argument, and will
+   return a DataFrame with these as columns. If len(q)==1 and a single
+   survival function is given, will return a scalar, not a DataFrame.
+   Also some good speed improvements.
+-  KaplanMeierFitter and NelsonAalenFitter now have a ``_label``
+   property that is passed in during the fit.
+-  KaplanMeierFitter/NelsonAalenFitter’s initial ``alpha`` value is
+   overwritten if a new ``alpha`` value is passed in during the ``fit``.
+-  New method for KaplanMeierFitter: ``conditional_time_to``. This
+   returns a DataFrame of the estimate: med(S(t \| T>s)) - s, human
+   readable: the estimated time left of living, given an individual is
+   aged s.
+-  Adds option ``include_likelihood`` to CoxPHFitter fit method to save
+   the final log-likelihood value.
+
+.. _section-132:
+
+0.4.2 - 2014-06-19
+------------------
+
+-  Massive speed improvements to CoxPHFitter.
+-  Additional prediction method: ``predict_percentile`` is available on
+   CoxPHFitter and AalenAdditiveFitter. Given a percentile, p, this
+   function returns the value t such that *S(t \| x) = p*. It is a
+   generalization of ``predict_median``.
+-  Additional kwargs in ``k_fold_cross_validation`` that will accept
+   different prediction methods (default is ``predict_median``).
+-  Bug fix in CoxPHFitter ``predict_expectation`` function.
+-  Correct spelling mistake in newton-rhapson algorithm.
+-  ``datasets`` now contains functions for generating the respective
+   datasets, ex: ``generate_waltons_dataset``.
+-  Bumping up the number of samples in statistical tests to prevent them
+   from failing so often (this a stop-gap)
+-  pep8 everything
+
+.. _section-133:
+
+0.4.1.1
+-------
+
+-  Ability to specify default printing in statistical tests with the
+   ``suppress_print`` keyword argument (default False).
+-  For the multivariate log rank test, the inverse step has been
+   replaced with the generalized inverse. This seems to be what other
+   packages use.
+-  Adding more robust cross validation scheme based on issue #67.
+-  fixing ``regression_dataset`` in ``datasets``.
+
+.. _section-134:
+
+0.4.1 - 2014-06-11
+------------------
+
+-  ``CoxFitter`` is now known as ``CoxPHFitter``
+-  refactoring some tests that used redundant data from
+   ``lifelines.datasets``.
+-  Adding cross validation: in ``utils`` is a new
+   ``k_fold_cross_validation`` for model selection in regression
+   problems.
+-  Change CoxPHFitter’s fit method’s ``display_output`` to ``False``.
+-  fixing bug in CoxPHFitter’s ``_compute_baseline_hazard`` that errored
+   when sending Series objects to ``survival_table_from_events``.
+-  CoxPHFitter’s ``fit`` now looks to columns with too low variance, and
+   halts NR algorithm if a NaN is found.
+-  Adding a Changelog.
+-  more sanitizing for the statistical tests =)
+
+.. _section-135:
+
+0.4.0 - 2014-06-08
+------------------
+
+-  ``CoxFitter`` implements Cox Proportional Hazards model in lifelines.
+-  lifelines moves the wheels distributions.
+-  tests in the ``statistics`` module now prints the summary (and still
+   return the regular values)
+-  new ``BaseFitter`` class is inherited from all fitters.

lifelines/source/docs/Citing lifelines.rst

@@ -0,0 +1,33 @@
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+
+Citing lifelines
+==================================
+
+*lifelines* is published in JOSS (August 2019):
+
+.. code-block:: python
+
+    Davidson-Pilon, (2019). lifelines: survival analysis in Python. Journal of Open Source Software, 4(40), 1317, https://doi.org/10.21105/joss.01317
+
+
+.. code-block:: python
+
+    @article{Davidson-Pilon2019,
+      doi = {10.21105/joss.01317},
+      url = {https://doi.org/10.21105/joss.01317},
+      year = {2019},
+      publisher = {The Open Journal},
+      volume = {4},
+      number = {40},
+      pages = {1317},
+      author = {Cameron Davidson-Pilon},
+      title = {lifelines: survival analysis in Python},
+      journal = {Journal of Open Source Software}
+    }
+
+
+
+See also the `Zenodo webpage <https://zenodo.org/record/4816284#.YR0RH9NKgr0>`_ for an up-to-date DOI for the software releases.

lifelines/source/docs/Contributing.rst

@@ -0,0 +1,93 @@
+Contributing to lifelines
+-------------------------
+
+Questions about survival analysis?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you are using lifelines for survival analysis and have a question
+about “how do I do X?” or “what does Y do?”, the best place to ask that
+is either in our `discussions
+channel <https://github.com/camdavidsonpilon/lifelines/discussions>`__ or at
+`stats.stackexchange.com <https://stats.stackexchange.com/>`__.
+
+Submitting bugs or other errors observed
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We appreciate all bug reports submitted, as this will help the entire
+community get a better product. Please open up an issue in the Github
+Repository. If possible, please provide a code snippet, and what version
+of lifelines you are using.
+
+Submitting new feature requests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Please open up an issue in the Github Repository with as much context as
+possible about the feature you would like to see. Also useful is to link
+to other libraries/software that have that feature.
+
+Submitting code, or other changes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you are interested in contributing to lifelines (and we thank you for
+the interest!), we recommend first opening up an issue in the GitHub
+repository to discuss the changes. From there, we can together plan how
+to execute the changes. See the Development section below for how to
+setup a local environment.
+
+Development
+-----------
+
+Setting up a lifelines development environment
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+1. From the root directory of ``lifelines`` activate your `virtual
+   environment <https://realpython.com/python-virtual-environments-a-primer/>`__
+   (if you plan to use one).
+2. Install the development requirements and
+   `pre-commit <https://pre-commit.com>`__ hooks. If you are on Mac,
+   Linux, or `Windows
+   WSL <https://docs.microsoft.com/en-us/windows/wsl/faq>`__ you can
+   use the provided
+   `Makefile <https://github.com/CamDavidsonPilon/lifelines/blob/master/Makefile>`__.
+   Just type ``make`` into the console and you’re ready to start
+   developing. This will also install the dev-requirements.
+
+Formatting
+~~~~~~~~~~
+
+``lifelines`` uses the `black <https://github.com/ambv/black>`__
+python formatter. There are 3 different ways to format your code.
+
+1. Use the
+   `Makefile <https://github.com/CamDavidsonPilon/lifelines/blob/master/Makefile>`__.
+
+    ``make lint``
+
+2. Call ``black`` directly and pass the correct line
+   length.
+
+    ``black . -l 120``
+
+3. Have your code formatted automatically
+   during commit with the ``pre-commit`` hook.
+
+   * Stage and commit your unformatted changes:
+
+      ``git commit -m "your_commit_message"``
+
+   * Code that needs to be formatted will “fail” the commit hooks and be
+     formatted for you.
+   * Stage the newly formatted python code:
+
+      ``git add *.py``
+
+   * Recall your original commit command and commit again:
+
+      ``git commit -m "your_commit_message"``
+
+Running the tests
+~~~~~~~~~~~~~~~~~
+
+You can optionally run the test suite after install with
+
+ ``py.test``

lifelines/source/docs/Examples.rst

@@ -0,0 +1,1097 @@
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+More examples and recipes
+==================================
+
+This section goes through some examples and recipes to help you use *lifelines*.
+
+
+
+Worked Examples
+####################
+
+If you are looking for some full examples of *lifelines*, there are `full Jupyter notebooks and scripts here <https://github.com/CamDavidsonPilon/lifelines/tree/master/examples>`_ and examples and ideas on the `development blog <https://dataorigami.net/blogs/napkin-folding/tagged/lifelines>`_.
+
+
+Statistically compare two populations
+##############################################
+
+Often researchers want to compare survival-ness between different populations. Here are some techniques to do that:
+
+
+
+Logrank test
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. note:: The logrank test has maximum power when the assumption of proportional hazards is true. As a consequence, if the survival functions cross, the logrank test will give an inaccurate assessment of differences.
+
+
+The :func:`lifelines.statistics.logrank_test` function compares whether the "death" generation process of the two populations are equal:
+
+.. code-block:: python
+
+    from lifelines.statistics import logrank_test
+    from lifelines.datasets import load_waltons
+
+    df = load_waltons()
+    ix = df['group'] == 'miR-137'
+    T_exp, E_exp = df.loc[ix, 'T'], df.loc[ix, 'E']
+    T_con, E_con = df.loc[~ix, 'T'], df.loc[~ix, 'E']
+
+
+    results = logrank_test(T_exp, T_con, event_observed_A=E_exp, event_observed_B=E_con)
+    results.print_summary()
+
+    """
+                  t_0 = -1
+                alpha = 0.95
+    null_distribution = chi squared
+                   df = 1
+       use_bonferroni = True
+
+    ---
+    test_statistic        p
+             3.528  0.00034  **
+
+
+    """
+
+    print(results.p_value)        # 0.46759
+    print(results.test_statistic) # 0.528
+
+
+If you have more than two populations, you can use :func:`~lifelines.statistics.pairwise_logrank_test` (which compares
+each pair in the same manner as above), or :func:`~lifelines.statistics.multivariate_logrank_test` (which tests the
+hypothesis that all the populations have the same "death" generation process).
+
+
+.. code-block:: python
+
+    import pandas as pd
+    from lifelines.statistics import multivariate_logrank_test
+
+    df = pd.DataFrame({
+        'durations': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'groups': [0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2], # could be strings too
+        'events': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
+    })
+
+    results = multivariate_logrank_test(df['durations'], df['groups'], df['events'])
+    results.print_summary()
+
+    """
+                  t_0 = -1
+                alpha = 0.95
+    null_distribution = chi squared
+                   df = 2
+
+    ---
+    test_statistic      p
+            1.0800 0.5827
+    ---
+    """
+
+The logrank test statistic is calculated from the differences between the observed deaths for a group and expected
+deaths, under the null hypothesis that all groups share the same survival curve, summed across all ordered death times.
+It therefore weights differences between the survival curves equally at each death time, resulting in maximum power
+when the assumption of proportional hazards is true. To test for early or late differences in survival between
+groups, a weighted logrank test that are more sensitive to non-proportional hazards might be a better choice.
+
+Four types of weighted logrank test are currently available in lifelines through the ``weightings`` argument:
+the Wilcoxon (``weightings='wilcoxon'``), Tarone-Ware (``weightings='tarone-ware'``), Peto (``weightings='peto'``)
+and Fleming-Harrington (``weightings='fleming-harrington'``) tests.
+The following weightings are applied at the ith ordered failure time, :math:`t_{i}`:
+
+    .. math:: \text{Wilcoxon:}\quad n_i
+    .. math:: \text{Tarone-Ware:}\quad \sqrt{n_i}
+    .. math:: \text{Peto:}\quad \bar{S}(t_i)
+    .. math:: \text{Fleming-Harrington}\quad \hat{S}(t_i)^p \times (1 - \hat{S}(t_i))^q
+
+where :math:`n_i` is the number at risk just prior to time :math:`t_{i}`, :math:`\bar{S}(t_i)` is
+Peto-Peto's modified survival estimate and :math:`\hat{S}(t_i)` is the left-continuous
+Kaplan-Meier survival estimate at time :math:`t_{i}`.
+
+The Wilcoxon, Tarone-Ware and Peto tests apply more weight to earlier death times. The Peto test is more robust than
+the Wilcoxon or Tarone-Ware tests when many observations are censored. When p > q, the Fleming-Harrington
+applies more weight to earlier death times whilst when p < q, it is more sensitive to late differences (for p=q=0 it
+reduces to the unweighted logrank test). The choice of which test to perform should be made in advance and not
+retrospectively to avoid introducing bias.
+
+.. code-block:: python
+
+    import pandas as pd
+    from lifelines.statistics import multivariate_logrank_test
+
+    df = pd.DataFrame({
+        'durations': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'groups': [0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2], # could be strings too
+        'events': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
+    })
+
+    results = multivariate_logrank_test(df['durations'], df['groups'], df['events'], weightings='peto')
+    results.print_summary()
+
+    """
+    t_0 = -1
+    null_distribution = chi squared
+    degrees_of_freedom = 2
+    test_name = multivariate_Peto_test
+    ---
+    test_statistic    p  -log2(p)
+              0.95 0.62      0.68
+    """
+
+Survival differences at a point in time
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Often analysts want to compare the survival-ness of groups at specific times, rather than comparing the entire survival curves against each other.  For example, analysts may be interested in 5-year survival. Statistically comparing the naive Kaplan-Meier points at a specific time
+actually has reduced power. By transforming the Kaplan-Meier curve, we can recover more power. The function :func:`lifelines.statistics.survival_difference_at_fixed_point_in_time_test` uses
+the log(-log) transformation implicitly and compares the survival-ness of populations at a specific point in time using chi-squared test.
+
+
+
+.. code-block:: python
+
+    from lifelines.statistics import survival_difference_at_fixed_point_in_time_test
+    from lifelines.datasets import load_waltons
+
+    df = load_waltons()
+    ix = df['group'] == 'miR-137'
+    T_exp, E_exp = df.loc[ix, 'T'], df.loc[ix, 'E']
+    T_con, E_con = df.loc[~ix, 'T'], df.loc[~ix, 'E']
+
+    kmf_exp = KaplanMeierFitter(label="exp").fit(T_exp, E_exp)
+    kmf_con = KaplanMeierFitter(label="con").fit(T_con, E_con)
+
+    point_in_time = 10.
+    results = survival_difference_at_fixed_point_in_time_test(point_in_time, kmf_exp, kmf_con)
+    results.print_summary()
+	
+	"""
+	t_0 = -1
+	null_distribution = chi squared
+	degrees_of_freedom = 1
+	point_in_time = 10.0
+	test_name = survival_difference_at_fixed_point_in_time_test
+	---
+	test_statistic    p  -log2(p)
+			  4.77 0.03      5.11  
+	"""
+	
+	
+Moreover, we can plot the two survival curves and compare them at the fixed point in time:
+
+	
+.. code-block:: python
+	
+	kmf_exp.plot_survival_function(point_in_time=point_in_time)
+	kmf_con.plot_survival_function(point_in_time=point_in_time)
+
+.. image:: images/plot_survival_difference_at_fixed_point_in_time_test.png	
+
+
+We can see that the expermintal's survival function value (blue) is lower than the control's group value (orange).
+It is worth observing that at that particular point, the confidence intervals for both groups overlap to some extent, which is not consistently observed at all other time points.	
+
+
+Restricted mean survival times (RMST)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+*lifelines* has a function to accurately compute the restricted mean survival time, defined as
+
+
+    .. math::  \text{RMST}(t) = \int_0^t S(\tau) d\tau
+
+
+This is a good metric for comparing two survival curves, as their difference represents the area between the curves (see figure below) which is a measure of "time lost". The upper limit of the integral above is often finite because the tail of the estimated survival curve has high variance and can strongly influence the integral.
+
+.. code-block:: python
+
+    from lifelines.utils import restricted_mean_survival_time
+    from lifelines.datasets import load_waltons
+    from lifelines import KaplanMeierFitter
+
+    df = load_waltons()
+    ix = df['group'] == 'miR-137'
+    T, E = df['T'], df['E']
+
+    time_limit = 50
+
+    kmf_exp = KaplanMeierFitter().fit(T[ix], E[ix], label='exp')
+    rmst_exp = restricted_mean_survival_time(kmf_exp, t=time_limit)
+
+    kmf_con = KaplanMeierFitter().fit(T[~ix], E[~ix], label='control')
+    rmst_con = restricted_mean_survival_time(kmf_con, t=time_limit)
+
+
+
+Furthermore, there exist plotting functions to plot the RMST:
+
+.. code-block:: python
+
+    from matplotlib import pyplot as plt
+    from lifelines.plotting import rmst_plot
+
+    ax = plt.subplot(311)
+    rmst_plot(kmf_exp, t=time_limit, ax=ax)
+
+
+    ax = plt.subplot(312)
+    rmst_plot(kmf_con, t=time_limit, ax=ax)
+
+
+    ax = plt.subplot(313)
+    rmst_plot(kmf_exp, model2=kmf_con, t=time_limit, ax=ax)
+
+
+
+.. image:: images/rmst_example.png
+
+
+
+Model selection using lifelines
+#####################################################
+
+If using *lifelines* for prediction work, it's ideal that you perform some type of cross-validation scheme. This cross-validation allows you to be confident that your out-of-sample predictions will work well in practice. It also allows you to choose between multiple models.
+
+*lifelines* has a built-in k-fold cross-validation function. For example, consider the following example:
+
+.. code-block:: python
+
+    import numpy as np
+    from lifelines import AalenAdditiveFitter, CoxPHFitter
+    from lifelines.datasets import load_regression_dataset
+    from lifelines.utils import k_fold_cross_validation
+
+    df = load_regression_dataset()
+
+    #create the three models we'd like to compare.
+    aaf_1 = AalenAdditiveFitter(coef_penalizer=0.5)
+    aaf_2 = AalenAdditiveFitter(coef_penalizer=10)
+    cph = CoxPHFitter()
+
+    print(np.mean(k_fold_cross_validation(cph, df, duration_col='T', event_col='E', scoring_method="concordance_index")))
+    print(np.mean(k_fold_cross_validation(aaf_1, df, duration_col='T', event_col='E', scoring_method="concordance_index")))
+    print(np.mean(k_fold_cross_validation(aaf_2, df, duration_col='T', event_col='E', scoring_method="concordance_index")))
+
+From these results, Aalen's Additive model with a penalizer of 10 is best model of predicting future survival times.
+
+*lifelines* also has wrappers to use scikit-learn's cross validation and grid search tools. See `how to use lifelines with scikit learn <https://lifelines.readthedocs.io/en/latest/Compatibility%20with%20scikit-learn.html>`_.
+
+Selecting a parametric model using QQ plots
+###############################################
+
+QQ plots normally are constructed by sorting the values. However, this isn't appropriate when there is censored data. In *lifelines*, there are routines to still create QQ plots with censored data. These are available under :func:`lifelines.plotting.qq_plots`, and accepts fitted a parametric lifelines model.
+
+.. code-block:: python
+
+    from lifelines import *
+    from lifelines.plotting import qq_plot
+
+    # generate some fake log-normal data
+    N = 1000
+    T_actual = np.exp(np.random.randn(N))
+    C = np.exp(np.random.randn(N))
+    E = T_actual < C
+    T = np.minimum(T_actual, C)
+
+    fig, axes = plt.subplots(2, 2, figsize=(8, 6))
+    axes = axes.reshape(4,)
+
+    for i, model in enumerate([WeibullFitter(), LogNormalFitter(), LogLogisticFitter(), ExponentialFitter()]):
+        model.fit(T, E)
+        qq_plot(model, ax=axes[i])
+
+.. image:: images/qq_plot.png
+
+
+This graphical test can be used to invalidate models. For example, in the above figure, we can see that only the log-normal parametric model is appropriate (we expect deviance in the tails, but not too much). Another use case is choosing the correct parametric AFT model.
+
+The :func:`~lifelines.plotting.qq_plots` also works with left censorship as well.
+
+Selecting a parametric model using AIC
+###############################################
+
+
+A natural way to compare different models is the AIC:
+
+.. math::  \text{AIC}(\text{model}) = -2 \text{ll} + 2k
+
+where :math:`k` is the number of parameters (degrees-of-freedom) of the model and :math:`\text{ll}` is the maximum log-likelihood. The model with the lowest AIC is desirable, since it's a trade off between maximizing the log-likelihood with as few parameters as possible.
+
+All lifelines models have the `AIC_` property after fitting.
+
+
+Further more, *lifelines* has a built in function to automate AIC comparisons between univariate parametric models:
+
+.. code:: python
+
+    from lifelines.utils import find_best_parametric_model
+    from lifelines.datasets import load_lymph_node
+
+    T = load_lymph_node()['rectime']
+    E = load_lymph_node()['censrec']
+
+    best_model, best_aic_ = find_best_parametric_model(T, E, scoring_method="AIC")
+
+    print(best_model)
+    # <lifelines.SplineFitter:"Spline_estimate", fitted with 686 total observations, 387 right-censored observations>
+
+    best_model.plot_hazard()
+
+.. image:: images/best_parametric_model.png
+    :width: 500px
+    :align: center
+
+Plotting multiple figures on a plot
+##############################################
+
+When ``.plot`` is called, an ``axis`` object is returned which can be passed into future calls of ``.plot``:
+
+.. code-block:: python
+
+    kmf.fit(data1)
+    ax = kmf.plot_survival_function()
+
+    kmf.fit(data2)
+    ax = kmf.plot_survival_function(ax=ax)
+
+
+If you have a pandas DataFrame with columns "T", "E", and some categorical variable, then something like the following would work:
+
+.. code-block:: python
+
+    from matplotlib import pyplot as plt
+
+    from lifelines.datasets import load_waltons
+    from lifelines import KaplanMeierFitter
+    df = load_waltons()
+
+    ax = plt.subplot(111)
+    kmf = KaplanMeierFitter()
+
+    for name, grouped_df in df.groupby('group'):
+        kmf.fit(grouped_df["T"], grouped_df["E"], label=name)
+        kmf.plot_survival_function(ax=ax)
+
+
+Plotting interval censored data
+##############################################
+
+.. note:: New in *lifelines* v0.24.6
+
+.. code-block:: python
+
+    from lifelines.datasets import load_diabetes
+    from lifelines.plotting import plot_interval_censored_lifetimes
+
+    df_sample = load_diabetes().sample(frac=0.02)
+    ax = plot_interval_censored_lifetimes(df_sample['left'], df_sample['right'])
+
+
+.. image:: /images/interval_censored_viz.png
+    :width: 500px
+    :align: center
+
+
+Plotting options and styles
+##############################################
+
+Let's load some data
+
+
+.. code-block:: python
+
+    from lifelines.datasets import load_waltons
+
+    waltons = load_waltons()
+    T = waltons['T']
+    E = waltons['E']
+
+
+Standard
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+
+    kmf = KaplanMeierFitter()
+    kmf.fit(T, E, label="kmf.plot_survival_function()")
+    kmf.plot_survival_function()
+
+.. image:: /images/normal_plot.png
+    :width: 500px
+    :align: center
+
+Show censors and edit markers
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    kmf.fit(T, E, label="kmf.plot_survival_function(show_censors=True, \ncensor_styles={'ms': 6, 'marker': 's'})")
+    kmf.plot_survival_function(show_censors=True, censor_styles={'ms': 6, 'marker': 's'})
+
+.. image:: images/flat_plot.png
+    :width: 500px
+    :align: center
+
+
+Hide confidence intervals
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    kmf.fit(T, E, label="kmf.plot_survival_function(ci_show=False)")
+    kmf.plot_survival_function(ci_show=False)
+
+.. image:: /images/ci_show_plot.png
+    :width: 500px
+    :align: center
+
+
+Displaying at-risk counts below plots
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    kmf.fit(T, E, label="label name")
+    kmf.plot_survival_function(at_risk_counts=True)
+    plt.tight_layout()
+
+
+
+.. image:: /images/single_at_risk_plots.png
+    :width: 500px
+    :align: center
+
+Displaying multiple at-risk counts below plots
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The function :func:`lifelines.plotting.add_at_risk_counts` allows you to add counts at the bottom of your figures. For example:
+
+.. code-block:: python
+
+    from lifelines import KaplanMeierFitter
+    from lifelines.datasets import load_waltons
+
+    waltons = load_waltons()
+    ix = waltons['group'] == 'control'
+
+    ax = plt.subplot(111)
+
+    kmf_control = KaplanMeierFitter()
+    ax = kmf_control.fit(waltons.loc[ix]['T'], waltons.loc[ix]['E'], label='control').plot_survival_function(ax=ax)
+
+    kmf_exp = KaplanMeierFitter()
+    ax = kmf_exp.fit(waltons.loc[~ix]['T'], waltons.loc[~ix]['E'], label='exp').plot_survival_function(ax=ax)
+
+
+    from lifelines.plotting import add_at_risk_counts
+    add_at_risk_counts(kmf_exp, kmf_control, ax=ax)
+    plt.tight_layout()
+
+will display
+
+.. image:: /images/add_at_risk.png
+    :width: 500px
+    :align: center
+
+Transforming survival-table data into *lifelines* format
+#########################################################
+
+Some *lifelines* classes are designed for lists or arrays that represent one individual per row. If you instead have data in a *survival table* format, there exists a utility method to get it into *lifelines* format.
+
+**Example:** Suppose you have a CSV file with data that looks like this:
+
+=========================   ==================    ============
+time                        observed deaths       censored
+=========================   ==================    ============
+0                               7                    0
+1                               1                    1
+2                               2                    0
+3                               1                    2
+4                               5                    2
+...                             ...                 ...
+=========================   ==================    ============
+
+
+.. code-block:: python
+
+    import pandas as pd
+    from lifelines.utils import survival_events_from_table
+
+    df = pd.read_csv('file.csv')
+    df = df.set_index('time')
+
+    T, E, W = survival_events_from_table(df, observed_deaths_col='observed deaths', censored_col='censored')
+    # weights, W, is the number of occurrences of each observation - helps with data compression.
+
+    kmf = KaplanMeierFitter().fit(T, E, weights=W)
+
+
+Transforming observational data into survival-table format
+##########################################################
+
+Perhaps you are interested in viewing the survival table given some durations and censoring vectors.
+
+
+.. code:: python
+
+    from lifelines.utils import survival_table_from_events
+
+    table = survival_table_from_events(T, E)
+    print(table.head())
+
+    """
+              removed  observed  censored  entrance  at_risk
+    event_at
+    0               0         0         0        60       60
+    2               2         1         1         0       60
+    3               3         1         2         0       58
+    4               5         3         2         0       55
+    5              12         6         6         0       50
+    """
+
+
+
+Set the index/timeline of a estimate
+##############################################
+
+Suppose your dataset has lifetimes grouped near time 60, thus after fitting
+:class:`lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter`, you survival function might look something like:
+
+.. code-block:: python
+
+    print(kmf.survival_function_)
+
+    """
+        KM-estimate
+    0          1.00
+    47         0.99
+    49         0.97
+    50         0.96
+    51         0.95
+    52         0.91
+    53         0.86
+    54         0.84
+    55         0.79
+    56         0.74
+    57         0.71
+    58         0.67
+    59         0.58
+    60         0.49
+    61         0.41
+    62         0.31
+    63         0.24
+    64         0.19
+    65         0.14
+    66         0.10
+    68         0.07
+    69         0.04
+    70         0.02
+    71         0.01
+    74         0.00
+    """
+
+
+What you would like is to have a predictable and full index from 40 to 75. (Notice that
+in the above index, the last two time points are not adjacent --  the cause is observing no lifetimes
+existing for times 72 or 73). This is especially useful for comparing multiple survival functions at specific time points. To do this, all fitter methods accept a ``timeline`` argument:
+
+.. code-block:: python
+
+    kmf.fit(T, timeline=range(40,75))
+    print(kmf.survival_function_)
+
+    """
+        KM-estimate
+    40         1.00
+    41         1.00
+    42         1.00
+    43         1.00
+    44         1.00
+    45         1.00
+    46         1.00
+    47         0.99
+    48         0.99
+    49         0.97
+    50         0.96
+    51         0.95
+    52         0.91
+    53         0.86
+    54         0.84
+    55         0.79
+    56         0.74
+    57         0.71
+    58         0.67
+    59         0.58
+    60         0.49
+    61         0.41
+    62         0.31
+    63         0.24
+    64         0.19
+    65         0.14
+    66         0.10
+    67         0.10
+    68         0.07
+    69         0.04
+    70         0.02
+    71         0.01
+    72         0.01
+    73         0.01
+    74         0.00
+    """
+
+
+*lifelines* will intelligently forward-fill the estimates to unseen time points.
+
+
+Example SQL query to get survival data from a table
+#####################################################
+
+Below is a way to get an example dataset from a relational database (this may vary depending on your database):
+
+.. code-block:: mysql
+
+    SELECT
+      id,
+      DATEDIFF('dd', started_at, COALESCE(ended_at, CURRENT_DATE)) AS "T",
+      (ended_at IS NOT NULL) AS "E"
+    FROM table
+
+Explanation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each row is an ``id``, a duration, and a boolean indicating whether the event occurred or not. Recall that we denote a
+"True" if the event *did* occur, that is, ``ended_at`` is filled in (we observed the ``ended_at``). Ex:
+
+==================   ============   ============
+id                   T                      E
+==================   ============   ============
+10                   40                 True
+11                   42                 False
+12                   42                 False
+13                   36                 True
+14                   33                 True
+==================   ============   ============
+
+
+Example SQL queries and transformations to get time varying data
+####################################################################
+
+For Cox time-varying models, we discussed what the dataset should look like in :ref:`Dataset creation for time-varying regression`. Typically we have a base dataset, and then we fold in the covariate datasets. Below are some SQL queries and Python transformations from end-to-end.
+
+
+Base dataset: ``base_df``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: mysql
+
+    SELECT
+      id,
+      group,
+      DATEDIFF('dd', dt.started_at, COALESCE(dt.ended_at, CURRENT_DATE)) AS "T",
+      (ended_at IS NOT NULL) AS "E"
+    FROM dimension_table dt
+
+
+Time-varying variables: ``cv``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: mysql
+
+    -- this could produce more than 1 row per subject
+    SELECT
+      id,
+      DATEDIFF('dd', dt.started_at, ft.event_at) AS "time",
+      ft.var1
+    FROM fact_table ft
+    JOIN dimension_table dt
+       USING(id)
+
+
+.. code-block:: python
+
+    from lifelines.utils import to_long_format
+    from lifelines.utils import add_covariate_to_timeline
+
+    base_df = to_long_format(base_df, duration_col="T")
+    df = add_covariate_to_timeline(base_df, cv, duration_col="time", id_col="id", event_col="E")
+
+
+Event variables: ``event_df``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Another very common operation is to add event data to our time-varying dataset. For example, a dataset/SQL table that contains information about the dates of an event (and NULLS if the event didn't occur). An example SQL query may look like:
+
+.. code-block:: mysql
+
+    SELECT
+      id,
+      DATEDIFF('dd', dt.started_at, ft.event1_at) AS "E1",
+      DATEDIFF('dd', dt.started_at, ft.event2_at) AS "E2",
+      DATEDIFF('dd', dt.started_at, ft.event3_at) AS "E3"
+      ...
+    FROM dimension_table dt
+
+
+In Pandas, this may look like:
+
+.. code-block:: python
+
+    """
+        id    E1      E2     E3
+    0   1     1.0     NaN    2.0
+    1   2     NaN     5.0    NaN
+    2   3     3.0     5.0    7.0
+    ...
+    """
+
+Initially, this can't be added to our baseline time-varying dataset. Using :func:`lifelines.utils.covariates_from_event_matrix` we can convert a DataFrame like this into one that can be easily added.
+
+.. code-block:: python
+
+    from lifelines.utils import covariates_from_event_matrix
+
+    cv = covariates_from_event_matrix(event_df, id_col='id')
+    print(cv)
+
+    """
+           id  duration  E1  E2  E3
+    0       1       1.0   1   0   0
+    1       1       2.0   0   1   0
+    2       2       5.0   0   1   0
+    3       3       3.0   1   0   0
+    4       3       5.0   0   1   0
+    5       3       7.0   0   0   1
+    """
+
+    base_df = add_covariate_to_timeline(base_df, cv, duration_col="time", id_col="id", event_col="E")
+
+
+Example cumulative sums over time-varying covariates
+############################################################
+
+Often we have either transactional covariate datasets or state covariate datasets. In a transactional dataset, it may make sense to sum up the covariates to represent administration of a treatment over time. For example, in the risky world of start-ups, we may want to sum up the funding amount received at a certain time. We also may be interested in the amount of the last round of funding. Below is an example to do just that:
+
+Suppose we have an initial DataFrame of start-ups like:
+
+.. code-block:: python
+
+    seed_df = pd.DataFrame([
+        {'id': 'FB', 'E': True, 'T': 12, 'funding': 0},
+        {'id': 'SU', 'E': True, 'T': 10, 'funding': 0},
+    ])
+
+
+And a covariate DataFrame representing funding rounds like:
+
+
+.. code-block:: python
+
+    cv = pd.DataFrame([
+        {'id': 'FB', 'funding': 30, 't': 5},
+        {'id': 'FB', 'funding': 15, 't': 10},
+        {'id': 'FB', 'funding': 50, 't': 15},
+        {'id': 'SU', 'funding': 10, 't': 6},
+        {'id': 'SU', 'funding': 9,  't':  10},
+    ])
+
+
+We can do the following to get both the cumulative funding received and the latest round of funding:
+
+.. code-block:: python
+
+    from lifelines.utils import to_long_format
+    from lifelines.utils import add_covariate_to_timeline
+
+    df = seed_df.pipe(to_long_format, 'T')\
+                .pipe(add_covariate_to_timeline, cv, 'id', 't', 'E', cumulative_sum=True)\
+                .pipe(add_covariate_to_timeline, cv, 'id', 't', 'E', cumulative_sum=False)
+
+
+    """
+       start  cumsum_funding  funding  stop  id      E
+    0      0             0.0      0.0   5.0  FB  False
+    1      5            30.0     30.0  10.0  FB  False
+    2     10            45.0     15.0  12.0  FB   True
+    3      0             0.0      0.0   6.0  SU  False
+    4      6            10.0     10.0  10.0  SU  False
+    5     10            19.0      9.0  10.0  SU   True
+    """
+
+
+Sample size determination under a CoxPH model
+##############################################
+
+Suppose you wish to measure the hazard ratio between two populations under the CoxPH model. That is, we want to evaluate the hypothesis
+H0: relative hazard ratio = 1 vs H1: relative hazard ratio != 1, where the relative hazard ratio is :math:`\exp{\left(\beta\right)}` for the experiment group vs the control group. A priori, we are interested in the sample sizes of the two groups necessary to achieve a certain statistical power. To do this in lifelines, there is the :func:`lifelines.statistics.sample_size_necessary_under_cph` function. For example:
+
+.. code-block:: python
+
+    from lifelines.statistics import sample_size_necessary_under_cph
+
+    desired_power = 0.8
+    ratio_of_participants = 1.
+    p_exp = 0.25
+    p_con = 0.35
+    postulated_hazard_ratio = 0.7
+    n_exp, n_con = sample_size_necessary_under_cph(desired_power, ratio_of_participants, p_exp, p_con, postulated_hazard_ratio)
+    # (421, 421)
+
+This assumes you have estimates of the probability of event occurring for both the experiment and control group. This could be determined from previous experiments.
+
+Power determination under a CoxPH model
+##############################################
+
+Suppose you wish to measure the hazard ratio between two populations under the CoxPH model. To determine the statistical power of a hazard ratio hypothesis test, under the CoxPH model, we can use :func:`lifelines.statistics.power_under_cph`. That is, suppose we want to know the probability that we reject the null hypothesis that the relative hazard ratio is 1, assuming the relative hazard ratio is truly different from 1. This function will give you that probability.
+
+
+.. code-block:: python
+
+    from lifelines.statistics import power_under_cph
+
+    n_exp = 50
+    n_con = 100
+    p_exp = 0.25
+    p_con = 0.35
+    postulated_hazard_ratio = 0.5
+    power = power_under_cph(n_exp, n_con, p_exp, p_con, postulated_hazard_ratio)
+    # 0.4957
+
+Problems with convergence in the Cox proportional hazard model
+################################################################
+Since the estimation of the coefficients in the Cox proportional hazard model is done using the Newton-Raphson algorithm, there are sometimes problems with convergence. Here are some common symptoms and resolutions:
+
+1. First check: look for ``ConvergenceWarning`` in the output. Most often problems in convergence are the result of problems in the dataset. *lifelines* has checks it runs against the dataset before fitting and warnings are outputted to the user.
+
+2. ``delta contains nan value(s).``: First try adding ``show_progress=True`` in the ``fit`` function. If the values in ``delta`` grow unbounded, it's possible the ``step_size`` is too large. Try setting it to a small value (0.1-0.5).
+
+3. ``Convergence halted due to matrix inversion problems``: This means that there is high collinearity in your dataset. That is, a column is equal to the linear combination of 1 or more other columns. A common cause of this error is dummying categorical variables but not dropping a column, or some hierarchical structure in your dataset.  Try to find the relationship by:
+
+   1. adding a penalizer to the model, ex: `CoxPHFitter(penalizer=0.1).fit(...)` until the model converges. In the `print_summary()`, the coefficients that have high collinearity will have large (absolute) magnitude in the `coefs` column.
+   2. using the variance inflation factor (VIF) to find redundant variables.
+   3. looking at the correlation matrix of your dataset, or
+
+4. Some coefficients are many orders of magnitude larger than others, and the standard error of the coefficient is also large *or* there are ``nan``'s in the results. This can be seen using the ``print_summary`` method on a fitted :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` object.
+
+   1. Look for a ``ConvergenceWarning`` about variances being too small. The dataset may contain a constant column, which provides no information for the regression (Cox model doesn't have a traditional "intercept" term like other regression models).
+
+   2. The data is completely separable, which means that there exists a covariate the completely determines whether an event occurred or not. For example, for all "death" events in the dataset, there exists a covariate that is constant amongst all of them. Look for a ``ConvergenceWarning`` after the ``fit`` call. See https://stats.stackexchange.com/questions/11109/how-to-deal-with-perfect-separation-in-logistic-regression
+
+   3. Related to above, the relationship between a covariate and the duration may be completely determined. For example, if the rank correlation between a covariate and the duration is very close to 1 or -1, then the log-likelihood can be increased arbitrarily using just that covariate. Look for a ``ConvergenceWarning`` after the ``fit`` call.
+
+   4. Another problem may be a collinear relationship in your dataset. See point 3. above.
+
+5. If adding a very small ``penalizer`` significantly changes the results (``CoxPHFitter(penalizer=0.0001)``), then this probably means that the step size in the iterative algorithm is too large. Try decreasing it (``.fit(..., step_size=0.50)`` or smaller), and returning the ``penalizer`` term to 0.
+
+6. If using the ``strata`` argument, make sure your stratification group sizes are not too small. Try ``df.groupby(strata).size()``.
+
+Adding weights to observations in a Cox model
+##############################################
+
+There are two common uses for weights in a model. The first is as a data size reduction technique (known as case weights). If the dataset has more than one subjects with identical attributes, including duration and event, then their likelihood contribution is the same as well. Thus, instead of computing the log-likelihood for each individual, we can compute it once and multiple it by the count of users with identical attributes. In practice, this involves first grouping subjects by covariates and counting. For example, using the Rossi dataset, we will use Pandas to group by the attributes (but other data processing tools, like Spark, could do this as well):
+
+.. code-block:: python
+
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    rossi_weights = rossi.copy()
+    rossi_weights['weights'] = 1.
+    rossi_weights = rossi_weights.groupby(rossi.columns.tolist())['weights'].sum()\
+                                 .reset_index()
+
+
+The original dataset has 432 rows, while the grouped dataset has 387 rows plus an additional ``weights`` column. :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` has an additional parameter to specify which column is the weight column.
+
+.. code-block:: python
+
+    from lifelines import CoxPHFitter
+
+    cph = CoxPHFitter()
+    cph.fit(rossi_weights, 'week', 'arrest', weights_col='weights')
+
+
+The fitting should be faster, and the results identical to the unweighted dataset. This option is also available in the :class:`~lifelines.fitters.cox_time_varying_fitter.CoxTimeVaryingFitter`.
+
+
+The second use of weights is sampling weights. These are typically positive, non-integer weights that represent some artificial under/over sampling of observations (ex: inverse probability of treatment weights). It is recommended to set ``robust=True`` in the call to the ``fit`` as the usual standard error is incorrect for sampling weights. The ``robust`` flag will use the sandwich estimator for the standard error.
+
+.. warning:: The implementation of the sandwich estimator does not handle ties correctly (under the Efron handling of ties), and will give slightly or significantly different results from other software depending on the frequency of ties.
+
+
+Correlations between subjects in a Cox model
+###################################################
+
+There are cases when your dataset contains correlated subjects, which breaks the independent-and-identically-distributed assumption. What are some cases when this may happen?
+
+1. If a subject appears more than once in the dataset (common when subjects can have the event more than once)
+2. If using a matching technique, like propensity-score matching, there is a correlation between pairs.
+
+In both cases, the reported standard errors from a unadjusted Cox model will be wrong. In order to adjust for these correlations, there is a ``cluster_col`` keyword in :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit` that allows you to specify the column in the DataFrame that contains designations for correlated subjects. For example, if subjects in rows 1 & 2 are correlated, but no other subjects are correlated, then ``cluster_col`` column should have the same value for rows 1 & 2, and all others unique. Another example: for matched pairs, each subject in the pair should have the same value.
+
+.. code-block:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+
+    # this may come from a database, or other libraries that specialize in matching
+    matched_pairs = [
+        (156, 230),
+        (275, 228),
+        (61, 252),
+        (364, 201),
+        (54, 340),
+        (130, 33),
+        (183, 145),
+        (268, 140),
+        (332, 259),
+        (314, 413),
+        (330, 211),
+        (372, 255),
+        # ...
+    ]
+
+    rossi['id'] = None  # we will populate this column
+
+    for i, pair in enumerate(matched_pairs):
+        subjectA, subjectB = pair
+        rossi.loc[subjectA, 'id'] = i
+        rossi.loc[subjectB, 'id'] = i
+
+    rossi = rossi.dropna(subset=['id'])
+
+    cph = CoxPHFitter()
+    cph.fit(rossi, 'week', 'arrest', cluster_col='id')
+
+Specifying ``cluster_col`` will handle correlations, and invoke the robust sandwich estimator for standard errors (the same as setting ``robust=True``).
+
+
+
+Serialize a *lifelines* model to disk
+##########################################
+
+When you want to save (and later load) a *lifelines* model to disk, you can use the `loads` and `dumps` API from most popular serialization library (dill, pickle, joblib):
+
+.. code-block:: python
+
+    from dill import loads, dumps
+    from pickle import loads, dumps
+
+    s_cph = dumps(cph)
+    cph_new = loads(s_cph)
+    cph_new.summary
+
+
+    s_kmf = dumps(kmf)
+    kmf_new = loads(s_kmf)
+    kmf_new.survival_function_
+    
+
+The codes above save the trained models as binary objects in memory. To serialize a *lifelines* model to a given path on disk:
+
+.. code-block:: python
+
+    import pickle
+
+    with open('/path/my.pickle', 'wb') as f:
+        pickle.dump(cph, f) # saving my trained cph model as my.pickle
+
+    with open('/path/my.pickle', 'rb') as f:
+        cph_new = pickle.load(f)
+
+    cph_new.summary # should produce the same output as cph.summary
+
+
+Produce a LaTex or HTML table
+##########################################
+
+New in version 0.23.1, *lifelines* models now have the ability to output a LaTeX or HTML table from the ``print_summary`` option:
+
+
+.. code-block:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+
+    cph = CoxPHFitter().fit(rossi, 'week', 'arrest')
+
+    # print a LaTeX table:
+    cph.print_summary(style="latex")
+
+    # print a HTML summary and table:
+    cph.print_summary(style="html")
+
+
+In order to use the produced table summary in LaTeX, make sure you import the package ``booktabs`` in your preamble (``\usepackage{booktabs}``), since it is required to `display the table properly. <https://en.wikibooks.org/wiki/LaTeX/Tables#Using_booktabs>`_
+
+
+Filter a ``print_summary`` table
+##########################################
+
+The information provided by ``print_summary`` can be a lot, and even too much for some screens. You can filter to specific columns use the ``columns`` kwarg (default is to display all columns):
+
+.. code-block:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+
+    cph = CoxPHFitter().fit(rossi, 'week', 'arrest')
+
+    cph.print_summary(columns=["coef", "se(coef)", "p"])
+
+
+
+Fixing a ``FormulaSyntaxError``
+##############################################
+
+As a of *lifelines* v0.25.0, formulas can be used to model your dataframe. This may cause problems if your dataframe has column names with spaces, periods, or other characters. The cheapest way to fix this is to change your column names:
+
+
+.. code-block:: python
+
+    df = pd.DataFrame({
+        'T': [1, 2, 3, 4],
+        'column with spaces': [1.5, 1.0, 2.5, 1.0],
+        'column.with.periods': [2.5, -1.0, -2.5, 1.0],
+        'column': [2.0, 1.0, 3.0, 4.0]
+    })
+
+    cph = CoxPHFitter().fit(df, 'T')
+
+    """
+    FormulaSyntaxError:
+        ...
+    """
+
+    df.columns = df.columns.str.replace(' ', '')
+    df.columns = df.columns.str.replace('.', '')
+    cph = CoxPHFitter().fit(df, 'T')
+
+    """
+    👍
+    """
+
+
+Another option is to use the formula syntax to handle this:
+
+
+.. code-block:: python
+
+    df = pd.DataFrame({
+        'T': [1, 2, 3, 4],
+        'column with spaces': [1.5, 1.0, 2.5, 1.0],
+        'column.with.periods': [2.5, -1.0, -2.5, 1.0],
+        'column': [2.0, 1.0, 3.0, 4.0]
+    })
+
+    cph = CoxPHFitter().fit(df, 'T', formula="column + Q('column with spaces') + Q('column.with.periods')")

lifelines/source/docs/Makefile

@@ -0,0 +1,177 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# User-friendly check for sphinx-build
+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
+endif
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/lifelines.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/lifelines.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/lifelines"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/lifelines"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."

lifelines/source/docs/Quickstart.rst

@@ -0,0 +1,366 @@
+.. _code_directive:
+
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+
+Quickstart
+''''''''''
+
+
+Installation
+------------
+
+Install via ``pip``:
+
+.. code-block:: console
+
+    pip install lifelines
+
+OR
+
+Install via `conda <https://anaconda.org/conda-forge/lifelines>`_:
+
+.. code-block:: console
+
+    conda install -c conda-forge lifelines
+
+
+Kaplan-Meier, Nelson-Aalen, and parametric models
+---------------------------------------------------
+
+.. note:: For readers looking for an introduction to survival analysis, it's recommended to start at :ref:`Introduction to Survival Analysis`
+
+
+Let's start by importing some data. We need the durations that individuals are observed for, and whether they "died" or not.
+
+
+.. code:: python
+
+    from lifelines.datasets import load_waltons
+    df = load_waltons() # returns a Pandas DataFrame
+
+    print(df.head())
+    """
+        T  E    group
+    0   6  1  miR-137
+    1  13  1  miR-137
+    2  13  1  miR-137
+    3  13  1  miR-137
+    4  19  1  miR-137
+    """
+
+    T = df['T']
+    E = df['E']
+
+``T`` is an array of durations, ``E`` is a either boolean or binary array representing whether the "death" was observed or not (alternatively an individual can be censored). We will fit a Kaplan Meier model to this, implemented as :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter`:
+
+
+
+.. code:: python
+
+    from lifelines import KaplanMeierFitter
+    kmf = KaplanMeierFitter()
+    kmf.fit(T, event_observed=E)  # or, more succinctly, kmf.fit(T, E)
+
+After calling the :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit` method, we have access to new properties like :attr:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.survival_function_` and methods like :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.plot`. The latter is a wrapper around Panda's internal plotting library.
+
+.. code:: python
+
+    kmf.survival_function_
+    kmf.cumulative_density_
+    kmf.plot_survival_function()
+
+
+.. image:: images/quickstart_kmf.png
+    :width: 620px
+    :align: center
+
+Alternatively, you can plot the cumulative density function:
+
+.. code:: python
+
+    kmf.plot_cumulative_density()
+
+.. image:: images/quickstart_kmf_cdf.png
+    :width: 620px
+    :align: center
+
+By specifying the ``timeline`` keyword argument in :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit`, we can change how the above models are indexed:
+
+.. code:: python
+
+    kmf.fit(T, E, timeline=range(0, 100, 2))
+
+    kmf.survival_function_   # index is now the same as range(0, 100, 2)
+    kmf.confidence_interval_ # index is now the same as range(0, 100, 2)
+
+
+A useful summary stat is the median survival time, which represents when 50% of the population has died:
+
+.. code:: python
+
+    from lifelines.utils import median_survival_times
+
+    median_ = kmf.median_survival_time_
+    median_confidence_interval_ = median_survival_times(kmf.confidence_interval_)
+
+
+Instead of the Kaplan-Meier estimator, you may be interested in a parametric model. *lifelines* has builtin parametric models. For example, Weibull, Log-Normal, Log-Logistic, and more.
+
+.. code:: python
+
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from lifelines import *
+
+    fig, axes = plt.subplots(3, 3, figsize=(13.5, 7.5))
+
+    kmf = KaplanMeierFitter().fit(T, E, label='KaplanMeierFitter')
+    wbf = WeibullFitter().fit(T, E, label='WeibullFitter')
+    exf = ExponentialFitter().fit(T, E, label='ExponentialFitter')
+    lnf = LogNormalFitter().fit(T, E, label='LogNormalFitter')
+    llf = LogLogisticFitter().fit(T, E, label='LogLogisticFitter')
+    pwf = PiecewiseExponentialFitter([40, 60]).fit(T, E, label='PiecewiseExponentialFitter')
+    ggf = GeneralizedGammaFitter().fit(T, E, label='GeneralizedGammaFitter')
+    sf = SplineFitter(np.percentile(T.loc[E.astype(bool)], [0, 50, 100])).fit(T, E, label='SplineFitter')
+
+    wbf.plot_survival_function(ax=axes[0][0])
+    exf.plot_survival_function(ax=axes[0][1])
+    lnf.plot_survival_function(ax=axes[0][2])
+    kmf.plot_survival_function(ax=axes[1][0])
+    llf.plot_survival_function(ax=axes[1][1])
+    pwf.plot_survival_function(ax=axes[1][2])
+    ggf.plot_survival_function(ax=axes[2][0])
+    sf.plot_survival_function(ax=axes[2][1])
+
+.. image:: images/waltons_survival_function.png
+
+
+Multiple groups
+^^^^^^^^^^^^^^^
+
+.. code:: python
+
+    groups = df['group']
+    ix = (groups == 'miR-137')
+
+    kmf.fit(T[~ix], E[~ix], label='control')
+    ax = kmf.plot_survival_function()
+
+    kmf.fit(T[ix], E[ix], label='miR-137')
+    ax = kmf.plot_survival_function(ax=ax)
+
+
+.. image:: images/quickstart_multi.png
+    :width: 620px
+    :align: center
+
+Alternatively, for many more groups and more "pandas-esque":
+
+.. code:: python
+
+
+    ax = plt.subplot(111)
+
+    kmf = KaplanMeierFitter()
+
+    for name, grouped_df in df.groupby('group'):
+        kmf.fit(grouped_df["T"], grouped_df["E"], label=name)
+        kmf.plot_survival_function(ax=ax)
+
+
+Similar functionality exists for the :class:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter`:
+
+.. code:: python
+
+    from lifelines import NelsonAalenFitter
+    naf = NelsonAalenFitter()
+    naf.fit(T, event_observed=E)
+
+but instead of a ``survival_function_`` being exposed, a ``cumulative_hazard_`` is.
+
+.. note:: Similar to `Scikit-Learn <http://scikit-learn.org>`_, all statistically estimated quantities append an underscore to the property name.
+
+.. note:: More detailed docs about estimating the survival function and cumulative hazard are available in `Survival analysis with lifelines`_.
+
+
+Getting data in the right format
+--------------------------------
+
+Often you'll have data that looks like:::
+
+    *start_time1*, *end_time1*
+    *start_time2*, *end_time2*
+    *start_time3*, None
+    *start_time4*, *end_time4*
+
+*lifelines* has some utility functions to transform this dataset into duration and censoring vectors. The most common one is :func:`lifelines.utils.datetimes_to_durations`.
+
+.. code:: python
+
+    from lifelines.utils import datetimes_to_durations
+
+    # start_times is a vector or list of datetime objects or datetime strings
+    # end_times is a vector or list of (possibly missing) datetime objects or datetime strings
+    T, E = datetimes_to_durations(start_times, end_times, freq='h')
+
+
+Perhaps you are interested in viewing the survival table given some durations and censoring vectors. The function :func:`lifelines.utils.survival_table_from_events` will help with that:
+
+
+.. code:: python
+
+    from lifelines.utils import survival_table_from_events
+
+    table = survival_table_from_events(T, E)
+    print(table.head())
+
+    """
+              removed  observed  censored  entrance  at_risk
+    event_at
+    0               0         0         0       163      163
+    6               1         1         0         0      163
+    7               2         1         1         0      162
+    9               3         3         0         0      160
+    13              3         3         0         0      157
+    """
+
+
+Survival regression
+-------------------
+
+While the above :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` model is useful, it only gives us an "average" view of the population. Often we have specific data at the individual level that we would like to use. For this, we turn to **survival regression**.
+
+.. note:: More detailed documentation and tutorials are available in `Survival Regression`_.
+
+
+The dataset for regression models is different than the datasets above. All the data, including durations, censored indicators and covariates must be contained in **a Pandas DataFrame**.
+
+.. code:: python
+
+    from lifelines.datasets import load_regression_dataset
+    regression_dataset = load_regression_dataset() # a Pandas DataFrame
+
+
+A regression model is instantiated, and a model is fit to a dataset using ``fit``. The duration column and event column are specified in the call to ``fit``. Below we model our regression dataset using the Cox proportional hazard model, full docs `here <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#cox-s-proportional-hazard-model>`_.
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+
+    # Using Cox Proportional Hazards model
+    cph = CoxPHFitter()
+    cph.fit(regression_dataset, 'T', event_col='E')
+    cph.print_summary()
+
+    """
+    <lifelines.CoxPHFitter: fitted with 200 total observations, 11 right-censored observations>
+                 duration col = 'T'
+                    event col = 'E'
+          baseline estimation = breslow
+       number of observations = 200
+    number of events observed = 189
+       partial log-likelihood = -807.62
+             time fit was run = 2020-06-21 12:26:28 UTC
+
+    ---
+           coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    var1   0.22       1.25       0.07             0.08             0.37                 1.08                 1.44
+    var2   0.05       1.05       0.08            -0.11             0.21                 0.89                 1.24
+    var3   0.22       1.24       0.08             0.07             0.37                 1.07                 1.44
+
+            z      p   -log2(p)
+    var1 2.99 <0.005       8.49
+    var2 0.61   0.54       0.89
+    var3 2.88 <0.005       7.97
+    ---
+    Concordance = 0.58
+    Partial AIC = 1621.24
+    log-likelihood ratio test = 15.54 on 3 df
+    -log2(p) of ll-ratio test = 9.47
+    """
+
+    cph.plot()
+
+.. image:: images/coxph_plot_quickstart.png
+    :width: 600px
+    :align: center
+
+The same dataset, but with a *Weibull accelerated failure time model*. This model was two parameters (see docs `here <https://lifelines.readthedocs.io/en/latest/fitters/regression/WeibullAFTFitter.html>`_), and we can choose to model both using our covariates or just one. Below we model just the scale parameter, ``lambda_``.
+
+.. code:: python
+
+    from lifelines import WeibullAFTFitter
+
+    wft = WeibullAFTFitter()
+    wft.fit(regression_dataset, 'T', event_col='E')
+    wft.print_summary()
+
+    """
+    <lifelines.WeibullAFTFitter: fitted with 200 total observations, 11 right-censored observations>
+                 duration col = 'T'
+                    event col = 'E'
+       number of observations = 200
+    number of events observed = 189
+               log-likelihood = -504.48
+             time fit was run = 2020-06-21 12:27:05 UTC
+
+    ---
+                         coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    lambda_ var1        -0.08       0.92       0.02            -0.13            -0.04                 0.88                 0.97
+            var2        -0.02       0.98       0.03            -0.07             0.04                 0.93                 1.04
+            var3        -0.08       0.92       0.02            -0.13            -0.03                 0.88                 0.97
+            Intercept   2.53      12.57       0.05             2.43             2.63                11.41                13.85
+    rho_    Intercept   1.09       2.98       0.05             0.99             1.20                 2.68                 3.32
+
+                           z      p   -log2(p)
+    lambda_ var1       -3.45 <0.005      10.78
+            var2       -0.56   0.57       0.80
+            var3       -3.33 <0.005      10.15
+            Intercept 51.12 <0.005        inf
+    rho_    Intercept 20.12 <0.005     296.66
+    ---
+    Concordance = 0.58
+    AIC = 1018.97
+    log-likelihood ratio test = 19.73 on 3 df
+    -log2(p) of ll-ratio test = 12.34
+    """
+
+    wft.plot()
+
+.. image:: images/waft_plot_quickstart.png
+    :width: 600px
+    :align: center
+
+Other AFT models are available as well, see `here <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#the-log-normal-and-log-logistic-aft-models>`_. An alternative regression model is Aalen's Additive model, which has time-varying hazards:
+
+.. code:: python
+
+    # Using Aalen's Additive model
+    from lifelines import AalenAdditiveFitter
+    aaf = AalenAdditiveFitter(fit_intercept=False)
+    aaf.fit(regression_dataset, 'T', event_col='E')
+
+
+Along with :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` and :class:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter`, after fitting you'll have access to properties like ``summary`` and methods like ``plot``, ``predict_cumulative_hazards``, and ``predict_survival_function``. The latter two methods require an additional argument of covariates:
+
+.. code:: python
+
+    X = regression_dataset.loc[0]
+
+    ax = wft.predict_survival_function(X).rename(columns={0:'WeibullAFT'}).plot()
+    cph.predict_survival_function(X).rename(columns={0:'CoxPHFitter'}).plot(ax=ax)
+    aaf.predict_survival_function(X).rename(columns={0:'AalenAdditive'}).plot(ax=ax)
+
+.. image:: images/quickstart_predict_aaf.png
+    :width: 620px
+    :align: center
+
+
+.. note:: More detailed documentation and tutorials are available in `Survival Regression`_.
+
+
+.. _Survival Regression: Survival%20Regression.html
+.. _Survival analysis with lifelines: Survival%20analysis%20with%20lifelines.html

lifelines/source/docs/References.rst

@@ -0,0 +1,11 @@
+API Reference
+==================================
+
+.. toctree::
+
+    lifelines.fitters
+    lifelines.utils
+    lifelines.statistics
+    lifelines.plotting
+    lifelines.datasets
+    lifelines.calibration

lifelines/source/docs/Survival Analysis intro.rst

@@ -0,0 +1,232 @@
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+
+Introduction to survival analysis
+'''''''''''''''''''''''''''''''''
+
+Applications
+------------
+
+
+Traditionally, survival analysis was developed to measure lifespans of individuals.
+An actuary or health professional would ask questions like
+"how long does this population live for?", and answer it using survival analysis.
+For example, the population may be a nation's population (for actuaries),
+or a population stricken by a disease (in the medical professional's case).
+Traditionally, sort of a morbid subject.
+
+But survival analysis can be applied to not only *births and
+deaths*, but *any* duration. Medical professionals might be interested in
+the *time between childbirths*, where a birth in this case is the event
+of having a child, and a death is becoming pregnant again! (obviously,
+we are loose with our definitions of *birth and death*) Another example
+is users subscribing to a service: a birth is a user who joins the
+service, and a death is when the user leaves the service.
+
+Censoring
+----------
+
+At the time you want to make inferences about durations, it is possible that not all the death events have occurred yet. For example, a
+medical professional will not wait 50 years for each individual in the
+study to pass away before investigating -- he or she is interested in
+making decisions after only a few years, or months possibly.
+
+The individuals in a population who have not been subject to the death
+event are labeled as *right-censored*, i.e.,
+we did not (or can not) view the rest of their life history
+due to some external circumstances. All the information we have on
+these individuals are their current lifetime durations (which is
+naturally *less* than their actual lifetimes).
+
+.. note:: There is also left-censoring and interval censoring, which are expanded on later.
+
+A common mistake data analysts make is choosing to ignore the
+right-censored individuals. We will see why this is a mistake next.
+
+Consider a case where the population is actually made up of two
+subpopulations, :math:`A` and :math:`B`. Population :math:`A` has a very
+small lifespan, say 2 months on average, and population :math:`B`
+enjoys a much larger lifespan, say 12 months on average. We don't
+know this distinction beforehand. At :math:`t=10`, we
+wish to investigate the average lifespan for the entire population.
+
+In the figure below, the red lines denote the lifespan of individuals where the death event
+has been observed, and the blue lines denote the lifespan of the
+right-censored individuals (deaths have not been observed). If we are
+asked to estimate the average lifetime of our population, and we naively
+decided to *not* included the right-censored individuals, it is clear
+that we would be severely underestimating the true average lifespan.
+
+.. code:: python
+
+
+    from lifelines.plotting import plot_lifetimes
+    import numpy as np
+    from numpy.random import uniform, exponential
+
+    N = 25
+
+    CURRENT_TIME = 10
+
+    actual_lifetimes = np.array([
+        exponential(12) if (uniform() < 0.5) else exponential(2) for i in range(N)
+    ])
+    observed_lifetimes = np.minimum(actual_lifetimes, CURRENT_TIME)
+    death_observed = actual_lifetimes < CURRENT_TIME
+
+    ax = plot_lifetimes(observed_lifetimes, event_observed=death_observed)
+
+    ax.set_xlim(0, 25)
+    ax.vlines(10, 0, 30, lw=2, linestyles='--')
+    ax.set_xlabel("time")
+    ax.set_title("Births and deaths of our population, at $t=10$")
+    print("Observed lifetimes at time %d:\n" % (CURRENT_TIME), observed_lifetimes)
+
+
+.. figure:: images/survival_analysis_intro_censoring.png
+    :width: 650px
+    :align: center
+    :figclass: align-center
+
+    Example lifetimes of individuals. We only observe up to time 10, but the blue individuals have not died yet (i.e. they are censored).
+
+
+.. parsed-literal::
+
+    Observed lifetimes at time 10:
+    [10.   1.1   8.   10.  3.43   0.63   6.28   1.03   2.37   6.17  10.
+       0.21   2.71   1.25  10.   3.4  0.62   1.94   0.22   7.43   6.16  10.
+       9.41  10.  10.]
+
+
+Furthermore, if we instead simply took the mean of *all*
+lifespans, including the current lifespans of right-censored instances,
+we would *still* be underestimating the true average lifespan. Below we
+plot the actual lifetimes of all instances (recall we do not see this
+information at :math:`t=10`).
+
+.. code:: python
+
+    ax = plot_lifetimes(actual_lifetimes, event_observed=death_observed)
+    ax.vlines(10, 0, 30, lw=2, linestyles='--')
+    ax.set_xlim(0, 25)
+
+
+.. figure:: images/survival_analysis_intro_censoring_revealed.png
+    :width: 650px
+    :align: center
+    :figclass: align-center
+
+    Revealing the actual lifetimes of individuals.
+
+
+Survival analysis was originally developed to solve this type of
+problem, that is, to deal with estimation when our data is
+right-censored. However, even in the case where all events have been
+observed, i.e. there is no censoring, survival analysis is still a very useful tool
+to understand durations and rates.
+
+The observations need not always start at zero, either. This was done
+only for understanding in the above example. Consider the example where
+a customer entering a store is a birth: a customer can enter at
+any time, and not necessarily at time zero. In survival analysis, durations
+are relative: individuals may start at different times.
+(We actually only need the *duration* of the observation, and not
+necessarily the start and end time.)
+
+We next introduce the three fundamental objects in survival analysis, the
+*survival function*, *hazard function* and the *cumulative hazard function*.
+
+--------------
+
+Survival function
+-----------------
+
+
+Let :math:`T` be a (possibly infinite, but always non-negative) random
+lifetime taken from the population under study. For example, the
+amount of time a couple is married. Or the time it takes a user to enter
+a webpage (an infinite time if they never do). The survival function -
+:math:`S(t)` - of a population is defined as
+
+.. math::  S(t) = Pr(T > t)
+
+Simply, the survival function defines the probability the death event has not occurred yet at time
+:math:`t`, or equivalently, the probability of surviving past time
+:math:`t`. Note the following properties of the survival function:
+
+1. :math:`0 \le S(t) \le 1`
+2. :math:`F_T(t) = 1 - S(t)`, where :math:`F_T(t)` is the CDF of :math:`T`, which implies
+3. :math:`S(t)` is a non-increasing function of :math:`t`.
+
+Here's an example of a survival function:
+
+.. image:: images/intro_survival_function.png
+    :width: 550px
+    :align: center
+
+Reading from this graph, we can see that at time 40, about 75% of the population is still alive.
+
+Hazard function
+-----------------
+
+
+We are also interested in the probability of the death event occurring at time :math:`t`,
+given that the death event has not occurred yet. Mathematically, that is:
+
+.. math::  \lim_{\delta t \rightarrow 0 } \; Pr( t \le T \le t + \delta t | T > t)
+
+This quantity goes to 0 as :math:`\delta t` shrinks, so we divide this
+by the interval :math:`\delta t` (like we might do in calculus). This
+defines the hazard function at time :math:`t`, :math:`h(t)`:
+
+.. math:: h(t) =  \lim_{\delta t \rightarrow 0 } \; \frac{Pr( t \le T \le t + \delta t | T > t)}{\delta t}
+
+It can be shown that this is equal to:
+
+.. math:: h(t) = \frac{-S'(t)}{S(t)}
+
+and solving this differential equation (cool, it is a differential
+equation!), we get:
+
+.. math:: S(t) = \exp\left( -\int_0^t h(z) \mathrm{d}z \right)
+
+The integral has a more common name: the *cumulative hazard function*, denoted :math:`H(t)`. We can rewrite the above as:
+
+
+.. math:: S(t) = \exp\left(-H(t) \right)
+
+
+With that, the two figures below represent the hazard and the cumulative hazard, respectively, of the survival function in the figure above.
+
+.. image:: images/intro_hazards.png
+    :width: 550px
+    :align: center
+
+
+
+What I like about the above relationships is that it defines **all** survival
+functions. Notice that we can now speak either about the
+survival function, :math:`S(t)`, the hazard, :math:`h(t)`, or the cumulative hazard function,
+:math:`H(t)`, and we can convert back and forth quite easily. Below is a graphic of all the relationships between the quantities.
+
+
+.. figure:: images/map.png
+    :width: 550px
+    :figwidth: 600px
+    :align: center
+    :figclass: align-center
+
+    Map of the mathematical entities used in survival analysis and the transforms between them.
+    Don't panic: *lifelines* does this all for you.
+
+
+
+
+Next steps
+-----------------
+
+Of course, we do not observe the true survival function or hazard of a population. We
+must use the observed data to estimate it. There are many ways to estimate the survival function and the hazard functions, which brings us to :doc:`estimation using lifelines</Survival analysis with lifelines>`.

lifelines/source/docs/Survival Regression.rst

@@ -0,0 +1,1298 @@
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+Survival regression
+#######################
+
+Often we have additional data aside from the duration that we want to use.
+The technique is called *survival regression* -- the name implies
+we regress covariates (e.g., age, country, etc.) against
+another variable -- in this case durations. Similar to the
+logic in the first part of this tutorial, we cannot use traditional
+methods like linear regression because of censoring.
+
+There are a few popular models in survival regression: Cox's
+model, accelerated failure models, and Aalen's additive model. All models attempt to represent the
+hazard rate :math:`h(t | x)` as a function of :math:`t` and some covariates :math:`x`. We explore these models next.
+
+
+The dataset for regression
+===========================
+The dataset required for survival regression must be in the format of a Pandas DataFrame. Each row of the DataFrame represents an observation. There should be a column denoting the durations of the observations. There may (or may not) be a column denoting the event status of each observation (1 if event occurred, 0 if censored). There are also the additional covariates you wish to regress against. Optionally, there could be columns in the DataFrame that are used for stratification, weights, and clusters which will be discussed later in this tutorial.
+
+
+An example dataset we will use is the Rossi recidivism dataset, available in *lifelines* as :meth:`~lifelines.datasets.load_rossi`.
+
+.. code:: python
+
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    """
+         week  arrest  fin  age  race  wexp  mar  paro  prio
+    0      20       1    0   27     1     0    0     1     3
+    1      17       1    0   18     1     0    0     1     8
+    2      25       1    0   19     0     1    0     1    13
+    3      52       0    1   23     1     1    1     1     1
+    """
+
+The DataFrame ``rossi`` contains 432 observations. The ``week`` column is the duration, the ``arrest`` column denotes if the event (a re-arrest) occurred, and the other columns represent variables we wish to regress against.
+
+
+Cox's proportional hazard model
+=================================
+
+The idea behind Cox's proportional hazard model is that the log-hazard of an individual is a linear function of their covariates *and* a population-level baseline hazard that changes over time. Mathematically:
+
+.. math::  \underbrace{h(t | x)}_{\text{hazard}} = \overbrace{b_0(t)}^{\text{baseline hazard}} \underbrace{\exp \overbrace{\left(\sum_{i=1}^n b_i (x_i - \overline{x_i})\right)}^{\text{log-partial hazard}}}_ {\text{partial hazard}}
+
+Note a few behaviors about this model: the only *time* component is in the baseline hazard, :math:`b_0(t)`. In the above equation, the partial hazard is a time-invariant scalar factor that only increases or decreases the baseline hazard. Thus changes in covariates will only inflate or deflate the baseline hazard.
+
+.. note:: In other regression models, a column of 1s might be added that represents that intercept or baseline. This is not necessary in the Cox model. In fact, there is no intercept in the Cox model - the baseline hazard represents this. *lifelines* will throw warnings and may experience convergence errors if a column of 1s is present in your dataset or formula.
+
+
+Fitting the regression
+-----------------------
+
+The implementation of the Cox model in *lifelines* is under :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter`. We fit the model to the dataset using :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit`. It has a :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.print_summary` function that prints a tabular view of coefficients and related stats.
+
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    cph = CoxPHFitter()
+    cph.fit(rossi, duration_col='week', event_col='arrest')
+
+    cph.print_summary()  # access the individual results using cph.summary
+
+    """
+    <lifelines.CoxPHFitter: fitted with 432 total observations, 318 right-censored observations>
+                 duration col = 'week'
+                    event col = 'arrest'
+       number of observations = 432
+    number of events observed = 114
+       partial log-likelihood = -658.75
+             time fit was run = 2019-10-05 14:24:44 UTC
+
+    ---
+           coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    fin   -0.38       0.68       0.19            -0.75            -0.00                 0.47                 1.00
+    age   -0.06       0.94       0.02            -0.10            -0.01                 0.90                 0.99
+    race   0.31       1.37       0.31            -0.29             0.92                 0.75                 2.50
+    wexp  -0.15       0.86       0.21            -0.57             0.27                 0.57                 1.30
+    mar   -0.43       0.65       0.38            -1.18             0.31                 0.31                 1.37
+    paro  -0.08       0.92       0.20            -0.47             0.30                 0.63                 1.35
+    prio   0.09       1.10       0.03             0.04             0.15                 1.04                 1.16
+
+             z      p   -log2(p)
+    fin  -1.98   0.05       4.40
+    age  -2.61   0.01       6.79
+    race  1.02   0.31       1.70
+    wexp -0.71   0.48       1.06
+    mar  -1.14   0.26       1.97
+    paro -0.43   0.66       0.59
+    prio  3.19 <0.005       9.48
+    ---
+    Concordance = 0.64
+    Partial AIC = 1331.50
+    log-likelihood ratio test = 33.27 on 7 df
+    -log2(p) of ll-ratio test = 15.37
+    """
+
+New in v0.25.0, We can also use ✨formulas✨ to handle the right-hand-side of the linear model. For example:
+
+.. code:: python
+
+    cph.fit(rossi, duration_col='week', event_col='arrest', formula="fin + wexp + age * prio")
+
+is analogous to the linear model with interaction term:
+
+.. math::
+   \beta_1\text{fin} + \beta_2\text{wexp} + \beta_3 \text{age} + \beta_4 \text{prio} + \beta_5 \text{age} \cdot \text{prio}
+
+.. code:: python
+
+    cph.fit(rossi, duration_col='week', event_col='arrest', formula="fin + wexp + age * prio")
+    cph.print_summary()
+
+    """
+    <lifelines.CoxPHFitter: fitted with 432 total observations, 318 right-censored observations>
+                 duration col = 'week'
+                    event col = 'arrest'
+          baseline estimation = breslow
+       number of observations = 432
+    number of events observed = 114
+       partial log-likelihood = -659.39
+             time fit was run = 2020-07-13 19:30:33 UTC
+
+    ---
+                coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    covariate
+    fin        -0.33       0.72       0.19            -0.70             0.04                 0.49                 1.05
+    wexp       -0.24       0.79       0.21            -0.65             0.17                 0.52                 1.19
+    age        -0.03       0.97       0.03            -0.09             0.03                 0.92                 1.03
+    prio        0.31       1.36       0.17            -0.03             0.64                 0.97                 1.90
+    age:prio   -0.01       0.99       0.01            -0.02             0.01                 0.98                 1.01
+
+                  z    p   -log2(p)
+    covariate
+    fin       -1.73 0.08       3.57
+    wexp      -1.14 0.26       1.97
+    age       -0.93 0.35       1.51
+    prio       1.80 0.07       3.80
+    age:prio  -1.28 0.20       2.32
+    ---
+    Concordance = 0.64
+    Partial AIC = 1328.77
+    log-likelihood ratio test = 31.99 on 5 df
+    -log2(p) of ll-ratio test = 17.35
+    """
+
+Formulas can be used to create interactions, encode categorical variables, create basis splines, and so on. The formulas used are (almost) the same as what's available in R and statsmodels.
+
+
+Interpretation
+-----------------------
+
+To access the coefficients and the baseline hazard directly, you can use :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.params_` and :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.baseline_hazard_` respectively. Taking a look at these coefficients for a moment, ``prio`` (the number of prior arrests) has a coefficient of about 0.09. Thus, a one unit increase in ``prio`` means the the baseline hazard will increase by a factor of :math:`\exp{(0.09)} = 1.10` - about a 10% increase. Recall, in the Cox proportional hazard model, a higher hazard means more at risk of the event occurring. The value :math:`\exp{(0.09)}` is called the *hazard ratio*, a name that will be clear with another example.
+
+Consider the coefficient of ``mar`` (whether the subject is married or not). The values in the column are binary: 0 or 1, representing either  unmarried or married. The value of the coefficient associated with ``mar``, :math:`\exp{(-.43)}`, is the value of ratio of *hazards* associated with being married, that is:
+
+.. math::
+
+ \exp(-0.43) = \frac{\text{hazard of married subjects at time $t$}}{\text{hazard of unmarried subjects at time $t$}}
+
+
+Note that left-hand side is a constant (specifically, it's independent of time, :math:`t`), but the right-hand side has two factors that may vary with time. The *proportional hazard assumption* is that relationship is true. That is, hazards can change over time, but their ratio between levels remains a constant. Later we will deal with checking this assumption. However, in reality, it's very common for the hazard ratio to change over the study duration. The hazard ratio then has the interpretation of some sort of weighted average of period-specific hazard ratios. As a result, the hazard ratio may critically depend on the duration of the follow-up.
+
+
+Convergence
+-----------------------
+
+Fitting the Cox model to the data involves using iterative methods. *lifelines* takes extra effort to help with convergence, so please be attentive to any warnings that appear. Fixing any warnings will generally help convergence and decrease the number of iterative steps required. If you wish to see more information during fitting, there is a ``show_progress`` parameter in :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit` function. For further help, see :ref:`Problems with convergence in the Cox Proportional Hazard Model`.
+
+After fitting, the value of the maximum log-likelihood this available using :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.log_likelihood_`. The variance matrix of the coefficients is available under :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.variance_matrix_`.
+
+
+Goodness of fit
+-----------------------
+
+After fitting, you may want to know how "good" of a fit your model was to the data. A few methods the author has found useful is to
+
+ - inspect the survival probability calibration plot (see below section on :ref:`Model probability calibration`)
+ - look at the concordance-index (see below section on :ref:`Model selection and calibration in survival regression`), available as :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.concordance_index_` or in the :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.print_summary` as a measure of predictive accuracy.
+ - look at the log-likelihood test result in the :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.print_summary` or :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.log_likelihood_ratio_test`
+ - check the proportional hazards assumption with the :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.check_assumptions` method. See section later on this page for more details.
+
+
+Prediction
+-----------------------
+
+
+After fitting, you can use use the suite of prediction methods: :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.predict_partial_hazard`, :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.predict_survival_function`, and others. See also the section on `Predicting censored subjects below <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#prediction-on-censored-subjects>`_
+
+.. code:: python
+
+    X = rossi
+
+    cph.predict_survival_function(X)
+    cph.predict_median(X)
+    cph.predict_partial_hazard(X)
+    ...
+
+
+
+Penalties and sparse regression
+-----------------------------------------------
+
+It's possible to add a penalizer term to the Cox regression as well. One can use these to i) stabilize the coefficients, ii) shrink the estimates to 0, iii) encourages a Bayesian viewpoint, and iv) create sparse coefficients. All regression models, including the Cox model, include both an L1 and L2 penalty:
+
+.. math:: \frac{1}{2} \text{penalizer} \left((1-\text{l1-ratio}) \cdot ||\beta||_2^2 + \text{l1-ratio} \cdot ||\beta||_1\right)
+
+
+.. note:: It's not clear from the above, but intercept (when applicable) are not penalized.
+
+
+To use this in *lifelines*, both the ``penalizer`` and ``l1_ratio`` can be specified in the class creation:
+
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    cph = CoxPHFitter(penalizer=0.1, l1_ratio=1.0) # sparse solutions,
+    cph.fit(rossi, 'week', 'arrest')
+    cph.print_summary()
+
+
+Instead of a float, an *array* can be provided that is the same size as the number of penalized parameters. The values in the array are specific penalty coefficients for each covariate. This is useful for more complicated covariate structure. Some examples:
+
+1. you have lots of confounders you wish to penalizer, but not the main treatment(s).
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    # variable `fin` is the treatment of interest so don't penalize it at all
+    penalty = np.array([0, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5])
+
+    cph = CoxPHFitter(penalizer=penalty)
+    cph.fit(rossi, 'week', 'arrest')
+    cph.print_summary()
+
+2. you have to `fuse categories together <https://stats.stackexchange.com/questions/146907/principled-way-of-collapsing-categorical-variables-with-many-levels>`_.
+
+3. you want to implement a `very sparse solution <https://dataorigami.net/blogs/napkin-folding/an-l1-2-penalty-in-cox-regression>`_.
+
+See more about penalties and their implementation on our development blog.
+
+ - `L₁ Penalty in Cox Regression <https://dataorigami.net/blogs/napkin-folding/l1-penalty-in-cox-regression>`_
+ - `An L½ penalty in Cox Regression <https://dataorigami.net/blogs/napkin-folding/an-l1-2-penalty-in-cox-regression>`_
+
+Plotting the coefficients
+------------------------------
+
+With a fitted model, an alternative way to view the coefficients and their ranges is to use the ``plot`` method.
+
+.. code:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+    cph = CoxPHFitter()
+    cph.fit(rossi, duration_col='week', event_col='arrest')
+
+    cph.plot()
+
+.. image:: images/coxph_plot.png
+    :width: 650px
+    :align: center
+
+
+Plotting the effect of varying a covariate
+-------------------------------------------
+
+
+
+After fitting, we can plot what the survival curves look like as we vary a single covariate while
+holding everything else equal. This is useful to understand the impact of a covariate, *given the model*. To do this, we use the :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.plot_partial_effects_on_outcome` method and give it the covariate of interest, and the values to display.
+
+.. note::
+    Prior to lifelines v0.25.0, this method used to be called ``plot_covariate_groups``. It's been renamed to ``plot_partial_effects_on_outcome`` (a much clearer name, I hope).
+
+
+.. code:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+    cph = CoxPHFitter()
+    cph.fit(rossi, duration_col='week', event_col='arrest')
+
+    cph.plot_partial_effects_on_outcome(covariates='prio', values=[0, 2, 4, 6, 8, 10], cmap='coolwarm')
+
+.. image:: images/coxph_plot_covarite_groups.png
+    :width: 600px
+    :align: center
+
+
+If there are derivative features in your dataset, for example, suppose you have included ``prio`` and ``prio**2`` in your dataset. It doesn't make sense to just vary ``year`` and leave ``year**2`` fixed. You'll need to specify manually the values the covariates take on in a N-d array or list (where N is the number of covariates being varied.)
+
+.. code:: python
+
+    rossi['prio**2'] = rossi['prio'] ** 2
+
+    cph.fit(rossi, 'week', 'arrest')
+
+    cph.plot_partial_effects_on_outcome(
+        covariates=['prio', 'prio**2'],
+        values=[
+            [0, 0],
+            [1, 1],
+            [2, 4],
+            [3, 9],
+            [8, 64],
+        ],
+        cmap='coolwarm')
+
+
+However, if you used the ``formula`` kwarg in fit, all the necessary transformations will be made internally for you.
+
+.. code:: python
+
+    cph.fit(rossi, 'week', 'arrest', formula="prio + I(prio**2)")
+
+    cph.plot_partial_effects_on_outcome(
+        covariates=['prio'],
+        values=[0, 1, 2, 3, 8],
+        cmap='coolwarm')
+
+This feature is also useful for analyzing categorical variables:
+
+.. code:: python
+
+    cph.plot_partial_effects_on_outcome(
+        covariates=["a_categorical_variable"]
+        values=["A", "B", ...],
+        plot_baseline=False)
+
+
+Checking the proportional hazards assumption
+-----------------------------------------------
+
+To make proper inferences, we should ask if our Cox model is appropriate for our dataset. Recall from above that when using the Cox model, we are implicitly applying the proportional hazard assumption. We should ask, does our dataset obey this assumption?
+
+
+:class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` has a :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.check_assumptions` method that will output violations of the proportional hazard assumption. For a tutorial on how to fix violations, see `Testing the Proportional Hazard Assumptions`_. Suggestions are to look for ways to *stratify* a column (see docs below), or use a `time varying model`_.
+
+.. note:: Checking assumptions like this is only necessary if your goal is inference or correlation. That is, you wish to understand the influence of a covariate on the survival duration & outcome. If your goal is prediction, checking model assumptions is less important since your goal is to maximize an accuracy metric, and not learn about *how* the model is making that prediction.
+
+
+Stratification
+-----------------------------------------------
+
+Sometimes one or more covariates may not obey the proportional hazard assumption. In this case, we can allow the covariate(s) to still be included in the model without estimating its effect. This is called stratification. At a high level, think of it as splitting the dataset into *m* smaller datasets, partitioned by the unique values of the stratifying covariate(s). Each dataset has its own baseline hazard (the non-parametric part of the model), but they all share the regression parameters (the parametric part of the model). Since covariates are the same within each dataset, there is no regression parameter for the covariates stratified on, hence they will not show up in the output. However there will be *m* baseline hazards under :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.baseline_cumulative_hazard_`.
+
+To specify variables to be used in stratification, we define them in the call to :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit`:
+
+.. code:: python
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+    rossi = load_rossi()
+
+    cph = CoxPHFitter()
+    cph.fit(rossi, 'week', event_col='arrest', strata=['wexp'])
+    cph.print_summary()
+
+    """
+    <lifelines.CoxPHFitter: fitted with 432 total observations, 318 right-censored observations>
+                 duration col = 'week'
+                    event col = 'arrest'
+                       strata = ['wexp']
+          baseline estimation = breslow
+       number of observations = 432
+    number of events observed = 114
+       partial log-likelihood = -580.89
+             time fit was run = 2020-08-09 21:25:37 UTC
+
+    ---
+                coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    covariate
+    fin        -0.38       0.68       0.19            -0.76            -0.01                 0.47                 0.99
+    age        -0.06       0.94       0.02            -0.10            -0.01                 0.90                 0.99
+    race        0.31       1.36       0.31            -0.30             0.91                 0.74                 2.49
+    mar        -0.45       0.64       0.38            -1.20             0.29                 0.30                 1.34
+    paro       -0.08       0.92       0.20            -0.47             0.30                 0.63                 1.35
+    prio        0.09       1.09       0.03             0.03             0.15                 1.04                 1.16
+                  z      p   -log2(p)
+    covariate
+    fin       -1.99   0.05       4.42
+    age       -2.64   0.01       6.91
+    race       1.00   0.32       1.65
+    mar       -1.19   0.23       2.09
+    paro      -0.42   0.67       0.57
+    prio       3.16 <0.005       9.33
+    ---
+    Concordance = 0.61
+    Partial AIC = 1173.77
+    log-likelihood ratio test = 23.77 on 6 df
+    -log2(p) of ll-ratio test = 10.77
+
+    """
+
+    cph.baseline_survival_.shape
+    # (49, 2)
+    cph.baseline_cumulative_hazard_.plot(drawstyle="steps")
+
+Weights & robust errors
+-----------------------------------------------
+
+Observations can come with weights, as well. These weights may be integer values representing some commonly occurring observation, or they may be float values representing some sampling weights (ex: inverse probability weights). In the :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit` method, an kwarg is present for specifying which column in the DataFrame should be used as weights, ex: ``CoxPHFitter(df, 'T', 'E', weights_col='weights')``.
+
+When using sampling weights, it's correct to also change the standard error calculations. That is done by turning on the ``robust`` flag in :meth:`~lifelines.fitters.coxph_fitter.CoxPHFitter.fit`. Internally, :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` will use the sandwich estimator to compute the errors.
+
+
+.. code:: python
+
+    import pandas as pd
+    from lifelines import CoxPHFitter
+
+    df = pd.DataFrame({
+        'T': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'E': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
+        'weights': [1.1, 0.5, 2.0, 1.6, 1.2, 4.3, 1.4, 4.5, 3.0, 3.2, 0.4, 6.2],
+        'month': [10, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'age': [4, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+    })
+
+    cph = CoxPHFitter()
+    cph.fit(df, 'T', 'E', weights_col='weights', robust=True)
+    cph.print_summary()
+
+See more examples in `Adding weights to observations in a Cox model <https://lifelines.readthedocs.io/en/latest/Examples.html#adding-weights-to-observations-in-a-cox-model>`_.
+
+Clusters & correlations
+-----------------------------------------------
+
+Another property your dataset may have is groups of related subjects. This could be caused by:
+
+ - a single individual having multiple occurrences, and hence showing up in the dataset more than once.
+ - subjects that share some common property, like members of the same family or being matched on propensity scores.
+
+We call these grouped subjects "clusters", and assume they are designated by some column in the DataFrame (example below). When using cluster, the point estimates of the model don't change, but the standard errors will increase. An intuitive argument for this is that 100 observations on 100 individuals provide more information than 100 observations on 10 individuals (or clusters).
+
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+
+    df = pd.DataFrame({
+        'T': [5, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'E': [1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0],
+        'month': [10, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'age': [4, 3, 9, 8, 7, 4, 4, 3, 2, 5, 6, 7],
+        'id': [1, 1, 1, 1, 2, 3, 3, 4, 4, 5, 6, 7]
+    })
+
+    cph = CoxPHFitter()
+    cph.fit(df, 'T', 'E', cluster_col='id')
+    cph.print_summary()
+
+
+For more examples, see `Correlations between subjects in a Cox model <https://lifelines.readthedocs.io/en/latest/Examples.html#correlations-between-subjects-in-a-cox-model>`_.
+
+Residuals
+-----------------------------------------------
+
+After fitting a Cox model, we can look back and compute important model residuals. These residuals can tell us about non-linearities not captured, violations of proportional hazards, and help us answer other useful modeling questions. See `Assessing Cox model fit using residuals`_.
+
+
+Modeling baseline hazard and survival with parametric models
+---------------------------------------------------------------
+
+Normally, the Cox model is *semi-parametric*, which means that its baseline hazard, :math:`h_0(t)`, has no parametric form. This is the default for *lifelines*. However, it is sometimes valuable to produce a parametric baseline instead. A parametric baseline makes survival predictions more efficient, allows for better understanding of baseline behaviour, and allows interpolation/extrapolation.
+
+In *lifelines*, there is an option to fit to a parametric baseline with 1) cubic splines, or 2) piecewise constant hazards. Cubic splines are highly flexible and can capture the underlying data almost as well as non-parametric methods, and with much more efficiency.
+
+.. code:: python
+
+
+    from lifelines.datasets import load_rossi
+    from lifelines import CoxPHFitter
+
+    rossi = load_rossi()
+
+    cph_spline = CoxPHFitter(baseline_estimation_method="spline", n_baseline_knots=5)
+    cph_spline.fit(rossi, 'week', event_col='arrest')
+
+To access the baseline hazard and baseline survival, one can use :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.baseline_hazard_` and :attr:`~lifelines.fitters.coxph_fitter.CoxPHFitter.baseline_survival_` respectively. One nice thing about parametric models is we can interpolate baseline survival / hazards  too, see :meth:`~lifelines.fitters.coxph_fitter.ParametricSplinePHFitter.baseline_hazard_at_times` and :meth:`~lifelines.fitters.coxph_fitter.ParametricSplinePHFitter.baseline_survival_at_times`.
+
+Below we compare the non-parametric and the fully parametric baseline survivals:
+
+.. code:: python
+
+    cph_semi = CoxPHFitter().fit(rossi, 'week', event_col='arrest')
+    cph_piecewise = CoxPHFitter(baseline_estimation_method="piecewise", breakpoints=[20, 35]).fit(rossi, 'week', event_col='arrest')
+
+    bch_key = "baseline cumulative hazard"
+
+    ax = cph_spline.baseline_cumulative_hazard_[bch_key].plot(label="spline")
+    cph_semi.baseline_cumulative_hazard_[bch_key].plot(ax=ax, drawstyle="steps-post", label="semi")
+    cph_piecewise.baseline_cumulative_hazard_[bch_key].plot(ax=ax, label="piecewise[20,35]")
+    plt.legend()
+
+
+.. figure:: images/spline_and_semi.png
+    :width: 600px
+    :align: center
+
+    Modeling the baseline survival with splines vs non-parametric.
+
+*lifelines'* spline Cox model can also use almost all the non-parametric options, including: `strata`, `penalizer`, `timeline`, `formula`, etc.
+
+
+
+Parametric survival models
+==================================
+
+We ended the previous section discussing a *fully*-parametric Cox model, but there are many many more parametric models to consider. Below we go over these, starting with the most common: AFT models.
+
+Accelerated failure time models
+-----------------------------------------------
+
+Suppose we have two populations, A and B, with different survival functions, :math:`S_A(t)` and :math:`S_B(t)`, and they are related by some *accelerated failure rate*, :math:`\lambda`:
+
+.. math::
+    S_A(t) = S_B\left(\frac{t}{\lambda}\right)
+
+This can be interpreted as slowing down or speeding up moving along the survival function. A classic example of this is that dogs age at 7 times the rate of humans, i.e. :math:`\lambda = \frac{1}{7}`. This model has some other nice properties: the average survival time of population B is :math:`{\lambda}` times the average survival time of population A. Likewise with the *median* survival time.
+
+More generally, we can model the :math:`\lambda` as a function of covariates available, that is:
+
+.. math::
+    S_A(t) = S_B\left(\frac{t}{\lambda(x)}\right)\\
+    \lambda(x) = \exp\left(b_0 + \sum_{i=1}^n b_i x_i \right)
+
+This model can accelerate or decelerate failure times depending on subjects' covariates. Another nice feature of this is the ease of interpretation of the coefficients: a unit increase in :math:`x_i` means the average/median survival time changes by a factor of :math:`\exp(b_i)`.
+
+
+.. note:: An important note on interpretation: Suppose :math:`b_i` was positive, then the factor :math:`\exp(b_i)` is greater than 1, which will decelerate the event time since we divide time by the factor ⇿ increase mean/median survival. Hence, it will be a *protective effect*. Likewise, a negative :math:`b_i` will hasten the event time ⇿ reduce the mean/median survival time. This interpretation is *opposite* of how the sign influences event times in the Cox model! This is standard survival analysis convention.
+
+
+Next, we pick a parametric form for the survival function, :math:`S(t)`. The most common is the Weibull form. So if we assume the relationship above and a Weibull form, our hazard function is quite easy to write down:
+
+.. math::
+    H(t; x) = \left( \frac{t}{\lambda(x)} \right)^\rho
+
+
+We call these accelerated failure time models, shortened often to just AFT models. Using *lifelines*, we can fit this model (and the unknown :math:`\rho` parameter too).
+
+The Weibull AFT model
+-----------------------------------------------
+
+
+The Weibull AFT model is implemented under :class:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter`. The API for the class is similar to the other regression models in *lifelines*. After fitting, the coefficients can be accessed using :attr:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.params_` or :attr:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.summary`, or alternatively printed using :meth:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.print_summary`.
+
+.. code:: python
+
+    from lifelines import WeibullAFTFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    aft = WeibullAFTFitter()
+    aft.fit(rossi, duration_col='week', event_col='arrest')
+
+    aft.print_summary(3)  # access the results using aft.summary
+
+    """
+    <lifelines.WeibullAFTFitter: fitted with 432 observations, 318 censored>
+          duration col = 'week'
+             event col = 'arrest'
+    number of subjects = 432
+      number of events = 114
+        log-likelihood = -679.917
+      time fit was run = 2019-02-20 17:47:19 UTC
+
+    ---
+                         coef  exp(coef)  se(coef)      z       p  -log2(p)  lower 0.95  upper 0.95
+    lambda_ fin         0.272      1.313     0.138  1.973   0.049     4.365       0.002       0.543
+            age         0.041      1.042     0.016  2.544   0.011     6.512       0.009       0.072
+            race       -0.225      0.799     0.220 -1.021   0.307     1.703      -0.656       0.207
+            wexp        0.107      1.112     0.152  0.703   0.482     1.053      -0.190       0.404
+            mar         0.311      1.365     0.273  1.139   0.255     1.973      -0.224       0.847
+            paro        0.059      1.061     0.140  0.421   0.674     0.570      -0.215       0.333
+            prio       -0.066      0.936     0.021 -3.143   0.002     9.224      -0.107      -0.025
+            Intercept  3.990     54.062     0.419  9.521 <0.0005    68.979       3.169       4.812
+    rho_    Intercept  0.339      1.404     0.089  3.809 <0.0005    12.808       0.165       0.514
+    ---
+    Concordance = 0.640
+    AIC = 1377.833
+    log-likelihood ratio test = 33.416 on 7 df
+    -log2(p) of ll-ratio test = 15.462
+    """
+
+From above, we can see that ``prio``, which is the number of previous incarcerations, has a large negative coefficient. This means that each addition incarcerations changes a subject's mean/median survival time by :math:`\exp(-0.066) = 0.936`, approximately a 7% decrease in mean/median survival time. What is the mean/median survival time?
+
+
+.. code:: python
+
+    print(aft.median_survival_time_)
+    print(aft.mean_survival_time_)
+
+    # 100.325
+    # 118.67
+
+
+What does the ``rho_    _intercept`` row mean in the above table? Internally, we model the log of the ``rho_`` parameter, so the value of :math:`\rho` is the exponential of the value, so in case above it's :math:`\hat{\rho} = \exp0.339 = 1.404`. This brings us to the next point - modelling :math:`\rho` with covariates as well:
+
+
+Modeling ancillary parameters
+-----------------------------------------------
+
+In the above model, we left the parameter :math:`\rho` as a single unknown. We can also choose to model this parameter as well. Why might we want to do this? It can help in survival prediction to allow heterogeneity in the :math:`\rho` parameter. The model is no longer an AFT model, but we can still recover and understand the influence of changing a covariate by looking at its outcome plot (see section below). To model :math:`\rho`, we use the ``ancillary`` keyword argument in the call to :meth:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.fit`. There are four valid options:
+
+1. ``False`` or ``None``: explicitly do not model the ``rho_`` parameter (except for its intercept).
+2. a Pandas DataFrame. This option will use the columns in the Pandas DataFrame as the covariates in the regression for ``rho_``. This DataFrame could be a equal to, or a subset of, the original dataset using for modeling ``lambda_``, or it could be a totally different dataset.
+3. ``True``. Passing in ``True`` will internally reuse the dataset that is being used to model ``lambda_``.
+4. A R-like formula.
+
+.. code:: python
+
+    aft = WeibullAFTFitter()
+
+    aft.fit(rossi, duration_col='week', event_col='arrest', ancillary=False)
+    # identical to aft.fit(rossi, duration_col='week', event_col='arrest', ancillary=None)
+
+
+    aft.fit(rossi, duration_col='week', event_col='arrest', ancillary=some_df)
+
+
+    aft.fit(rossi, duration_col='week', event_col='arrest', ancillary=True)
+    # identical to aft.fit(rossi, duration_col='week', event_col='arrest', ancillary=rossi)
+    # identical to aft.fit(rossi, duration_col='week', event_col='arrest', ancillary="fin + age + race + wexp + mar + paro + prio")
+
+    aft.print_summary()
+
+    """
+    <lifelines.WeibullAFTFitter: fitted with 432 observations, 318 censored>
+          duration col = 'week'
+             event col = 'arrest'
+    number of subjects = 432
+      number of events = 114
+        log-likelihood = -669.40
+      time fit was run = 2019-02-20 17:42:55 UTC
+
+    ---
+                        coef  exp(coef)  se(coef)     z      p  -log2(p)  lower 0.95  upper 0.95
+    lambda_ fin         0.24       1.28      0.15  1.60   0.11      3.18       -0.06        0.55
+            age         0.10       1.10      0.03  3.43 <0.005     10.69        0.04        0.16
+            race        0.07       1.07      0.19  0.36   0.72      0.48       -0.30        0.44
+            wexp       -0.34       0.71      0.15 -2.22   0.03      5.26       -0.64       -0.04
+            mar         0.26       1.30      0.30  0.86   0.39      1.35       -0.33        0.85
+            paro        0.09       1.10      0.15  0.61   0.54      0.88       -0.21        0.39
+            prio       -0.08       0.92      0.02 -4.24 <0.005     15.46       -0.12       -0.04
+            Intercept  2.68      14.65      0.60  4.50 <0.005     17.14        1.51        3.85
+    rho_    fin        -0.01       0.99      0.15 -0.09   0.92      0.11       -0.31        0.29
+            age        -0.05       0.95      0.02 -3.10 <0.005      9.01       -0.08       -0.02
+            race       -0.46       0.63      0.25 -1.79   0.07      3.77       -0.95        0.04
+            wexp        0.56       1.74      0.17  3.32 <0.005     10.13        0.23        0.88
+            mar         0.10       1.10      0.27  0.36   0.72      0.47       -0.44        0.63
+            paro        0.02       1.02      0.16  0.12   0.90      0.15       -0.29        0.33
+            prio        0.03       1.03      0.02  1.44   0.15      2.73       -0.01        0.08
+            Intercept  1.48       4.41      0.41  3.60 <0.005     11.62        0.68        2.29
+    ---
+    Concordance = 0.63
+    Log-likelihood ratio test = 54.45 on 14 df, -log2(p)=19.83
+    """
+
+
+
+Plotting
+-----------------------------------------------
+
+The plotting API is the same as in :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter`. We can view all covariates in a forest plot:
+
+.. code:: python
+
+    from matplotlib import pyplot as plt
+
+    wft = WeibullAFTFitter().fit(rossi, 'week', 'arrest', ancillary=True)
+    wft.plot()
+
+.. image:: images/weibull_aft_forest.png
+    :width: 650px
+    :align: center
+
+
+We can observe the influence a variable in the model by plotting the *outcome* (i.e. survival) of changing the variable. This is done using :meth:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.plot_partial_effects_on_outcome`, and this is also a nice time to observe the effects of modeling ``rho_`` vs keeping it fixed. Below we fit the Weibull model to the same dataset twice, but in the first model we model ``rho_`` and in the second model we don't. We when vary the ``prio`` (which is the number of prior arrests) and observe how the survival changes.
+
+
+.. note::
+    Prior to lifelines v0.25.0, this method used to be called ``plot_covariate_group``. It's been renamed to ``plot_partial_effects_on_outcome`` (a much clearer name, I hope).
+
+.. code:: python
+
+    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))
+
+    times = np.arange(0, 100)
+    wft_model_rho = WeibullAFTFitter().fit(rossi, 'week', 'arrest', ancillary=True, timeline=times)
+    wft_model_rho.plot_partial_effects_on_outcome('prio', range(0, 16, 3), cmap='coolwarm', ax=ax[0])
+    ax[0].set_title("Modelling rho_")
+
+    wft_not_model_rho = WeibullAFTFitter().fit(rossi, 'week', 'arrest', ancillary=False, timeline=times)
+    wft_not_model_rho.plot_partial_effects_on_outcome('prio', range(0, 16, 3), cmap='coolwarm', ax=ax[1])
+    ax[1].set_title("Not modelling rho_");
+
+.. image:: images/weibull_aft_two_models.png
+
+
+Comparing a few of these survival functions side by side, be can see that modeling ``rho_`` produces a more flexible (diverse) set of survival functions.
+
+.. code:: python
+
+    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(7, 4))
+
+    # modeling rho == solid line
+    wft_model_rho.plot_partial_effects_on_outcome('prio', range(0, 16, 5), cmap='coolwarm', ax=ax, lw=2, plot_baseline=False)
+
+    # not modeling rho == dashed line
+    wft_not_model_rho.plot_partial_effects_on_outcome('prio', range(0, 16, 5), cmap='coolwarm', ax=ax, ls='--', lw=2, plot_baseline=False)
+
+    ax.get_legend().remove()
+
+.. image:: images/weibull_aft_two_models_side_by_side.png
+    :width: 500px
+    :align: center
+
+You read more about and see other examples of the extensions to in the docs for :meth:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter.plot_partial_effects_on_outcome`
+
+
+Prediction
+-----------------------------------------------
+
+Given a new subject, we'd like to ask questions about their future survival. When are they likely to experience the event? What does their survival function look like? The :class:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter` is able to answer these. If we have modeled the ancillary covariates, we are required to include those as well:
+
+.. code:: python
+
+    X = rossi.loc[:10]
+
+    aft.predict_cumulative_hazard(X, ancillary=X)
+    aft.predict_survival_function(X, ancillary=X)
+    aft.predict_median(X, ancillary=X)
+    aft.predict_percentile(X, p=0.9, ancillary=X)
+    aft.predict_expectation(X, ancillary=X)
+
+
+There are two hyper-parameters that can be used to to achieve a better test score. These are ``penalizer`` and ``l1_ratio`` in the call to :class:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter`. The penalizer is similar to scikit-learn's ``ElasticNet`` model, see their `docs <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html>`_. (However, *lifelines* will also accept an array for custom penalty value per variable, see `Cox docs above <https://lifelines.readthedocs.io/en/latest/Survival%20Regression.html#penalties-and-sparse-regression>`_)
+
+.. code:: python
+
+
+    aft_with_elastic_penalty = WeibullAFTFitter(penalizer=1e-4, l1_ratio=1.0)
+    aft_with_elastic_penalty.fit(rossi, 'week', 'arrest')
+    aft_with_elastic_penalty.predict_median(rossi)
+
+    aft_with_elastic_penalty.print_summary(columns=['coef', 'exp(coef)'])
+
+    """
+    <lifelines.WeibullAFTFitter: fitted with 432 total observations, 318 right-censored observations>
+                 duration col = 'week'
+                    event col = 'arrest'
+                    penalizer = 0.0001
+       number of observations = 432
+    number of events observed = 114
+               log-likelihood = -679.97
+             time fit was run = 2020-08-09 15:04:35 UTC
+
+    ---
+                        coef  exp(coef)
+    param   covariate
+    lambda_ age         0.04       1.04
+            fin         0.27       1.31
+            mar         0.31       1.36
+            paro        0.06       1.06
+            prio       -0.07       0.94
+            race       -0.22       0.80
+            wexp        0.11       1.11
+            Intercept   3.99      54.11
+    rho_    Intercept   0.34       1.40
+    ---
+    Concordance = 0.64
+    AIC = 1377.93
+    log-likelihood ratio test = 33.31 on 7 df
+    -log2(p) of ll-ratio test = 15.40
+
+    """
+
+
+The log-normal and log-logistic AFT models
+-----------------------------------------------
+
+There are also the :class:`~lifelines.fitters.log_normal_aft_fitter.LogNormalAFTFitter` and :class:`~lifelines.fitters.log_logistic_aft_fitter.LogLogisticAFTFitter` models, which instead of assuming that the survival time distribution is Weibull, we assume it is Log-Normal or Log-Logistic, respectively. They have identical APIs to the :class:`~lifelines.fitters.weibull_aft_fitter.WeibullAFTFitter`, but the parameter names are different.
+
+
+.. code:: python
+
+    from lifelines import LogLogisticAFTFitter
+    from lifelines import LogNormalAFTFitter
+
+    llf = LogLogisticAFTFitter().fit(rossi, 'week', 'arrest')
+    lnf = LogNormalAFTFitter().fit(rossi, 'week', 'arrest')
+
+More AFT models: CRC model and generalized gamma model
+------------------------------------------------------------
+
+For a flexible and *smooth* parametric model, there is the :class:`~lifelines.fitters.generalized_gamma_regression_fitter.GeneralizedGammaRegressionFitter`. This model is actually a generalization of all the AFT models above (that is, specific values of its parameters represent another model ) - see docs for specific parameter values. The API is slightly different however, and looks more like how custom regression models are built (see next section on *Custom Regression Models*).
+
+.. code:: python
+
+    from lifelines import GeneralizedGammaRegressionFitter
+    from lifelines.datasets import load_rossi
+
+    df = load_rossi()
+    df['Intercept'] = 1.
+
+    # this will regress df against all 3 parameters
+    ggf = GeneralizedGammaRegressionFitter(penalizer=1.).fit(df, 'week', 'arrest')
+    ggf.print_summary()
+
+    # If we want fine control over the parameters <-> covariates.
+    # The values in the dict become can be formulas, or column names in lists:
+    regressors = {
+        'mu_': rossi.columns.difference(['arrest', 'week']),
+        'sigma_': ["age", "Intercept"],
+        'lambda_': 'age + 1',
+    }
+
+    ggf = GeneralizedGammaRegressionFitter(penalizer=0.0001).fit(df, 'week', 'arrest', regressors=regressors)
+    ggf.print_summary()
+
+Similarly, there is the CRC model that is uses splines to model the time. See a blog post about it `here <https://dataorigami.net/blogs/napkin-folding/an-accelerated-lifetime-spline-model>`_.
+
+
+The piecewise-exponential regression models
+-------------------------------------------------------------------------
+
+Another class of parametric models involves more flexible modeling of the hazard function. The :class:`~lifelines.fitters.piecewise_exponential_regression_fitter.PiecewiseExponentialRegressionFitter` can model jumps in the hazard (think: the differences in "survival-of-staying-in-school" between 1st year, 2nd year, 3rd year, and 4th year students), and constant values between jumps. The ability to specify *when* these jumps occur, called breakpoints, offers modelers great flexibility. An example application involving customer churn is available in this `notebook <https://github.com/CamDavidsonPilon/lifelines/blob/master/examples/SaaS%20churn%20and%20piecewise%20regression%20models.ipynb>`_.
+
+.. image:: images/piecewise_churn.png
+
+
+AIC and model selection for parametric models
+-----------------------------------------------
+
+Often, you don't know *a priori* which parametric model to use. Each model has some assumptions built-in (not implemented yet in *lifelines*), but a quick and effective method is to compare the `AICs <https://en.wikipedia.org/wiki/Akaike_information_criterion>`_ for each fitted model. (In this case, the number of parameters for each model is the same, so really this is comparing the log-likelihood). The model with the smallest AIC does the best job of fitting to the data with a minimal degrees of freedom.
+
+.. code:: python
+
+    from lifelines import LogLogisticAFTFitter, WeibullAFTFitter, LogNormalAFTFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    llf = LogLogisticAFTFitter().fit(rossi, 'week', 'arrest')
+    lnf = LogNormalAFTFitter().fit(rossi, 'week', 'arrest')
+    wf = WeibullAFTFitter().fit(rossi, 'week', 'arrest')
+
+    print(llf.AIC_)  # 1377.877
+    print(lnf.AIC_)  # 1384.469
+    print(wf.AIC_)   # 1377.833, slightly the best model.
+
+
+    # with some heterogeneity in the ancillary parameters
+    ancillary = rossi[['prio']]
+    llf = LogLogisticAFTFitter().fit(rossi, 'week', 'arrest', ancillary=ancillary)
+    lnf = LogNormalAFTFitter().fit(rossi, 'week', 'arrest', ancillary=ancillary)
+    wf = WeibullAFTFitter().fit(rossi, 'week', 'arrest', ancillary=ancillary)
+
+    print(llf.AIC_) # 1377.89, the best model here, but not the overall best.
+    print(lnf.AIC_) # 1380.79
+    print(wf.AIC_)  # 1379.21
+
+
+Left, right and interval censored data
+-----------------------------------------------
+
+The parametric models have APIs that handle left and interval censored data, too. The API for them is different than the API for fitting to right censored data. Here's an example with interval censored data.
+
+.. code:: python
+
+    from lifelines.datasets import load_diabetes
+
+    df = load_diabetes()
+    df['gender'] = df['gender'] == 'male'
+
+    print(df.head())
+    """
+       left  right  gender
+    1    24     27    True
+    2    22     22   False
+    3    37     39    True
+    4    20     20    True
+    5     1     16    True
+    """
+
+    wf = WeibullAFTFitter().fit_interval_censoring(df, lower_bound_col='left', upper_bound_col='right')
+    wf.print_summary()
+
+    """
+    <lifelines.WeibullAFTFitter: fitted with 731 total observations, 136 interval-censored observations>
+              lower bound col = 'left'
+              upper bound col = 'right'
+                    event col = 'E_lifelines_added'
+       number of observations = 731
+    number of events observed = 595
+               log-likelihood = -2027.20
+             time fit was run = 2020-08-09 15:05:09 UTC
+
+    ---
+                        coef  exp(coef)   se(coef)   coef lower 95%   coef upper 95%  exp(coef) lower 95%  exp(coef) upper 95%
+    param   covariate
+    lambda_ gender      0.05       1.05       0.03            -0.01             0.10                 0.99                 1.10
+            Intercept   2.91      18.32       0.02             2.86             2.95                17.53                19.14
+    rho_    Intercept   1.04       2.83       0.03             0.98             1.09                 2.67                 2.99
+                           z      p   -log2(p)
+    param   covariate
+    lambda_ gender      1.66   0.10       3.38
+            Intercept 130.15 <0.005        inf
+    rho_    Intercept  36.91 <0.005     988.46
+    ---
+    AIC = 4060.39
+    log-likelihood ratio test = 2.74 on 1 df
+    -log2(p) of ll-ratio test = 3.35
+    """
+
+
+Another example of using lifelines for interval censored data is located `here <https://dataorigami.net/blogs/napkin-folding/counting-and-interval-censoring>`_.
+
+
+Custom parametric regression models
+-------------------------------------
+
+*lifelines* has a very general syntax for creating your own parametric regression models. If you are looking to create your own custom models, see docs `Custom Regression Models`_.
+
+
+
+Aalen's additive model
+=============================
+
+.. warning:: This implementation is still experimental.
+
+Aalen's Additive model is another regression model we can use. Like the Cox model, it defines
+the hazard rate, but instead of the linear model being multiplicative like the Cox model, the Aalen model is
+additive. Specifically:
+
+
+.. math::
+    h(t|x)  = b_0(t) + b_1(t) x_1 + ... + b_N(t) x_N
+
+
+Inference typically does not estimate the individual
+:math:`b_i(t)` but instead estimates :math:`\int_0^t b_i(s) \; ds`
+(similar to the estimate of the hazard rate using ``NelsonAalenFitter``). This is important
+when interpreting plots produced.
+
+
+For this
+exercise, we will use the regime dataset and include the categorical
+variables ``un_continent_name`` (eg: Asia, North America,...), the
+``regime`` type (e.g., monarchy, civilian,...) and the year the regime
+started in, ``start_year``. The estimator to fit unknown coefficients in Aalen's additive model is
+located under :class:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter`.
+
+.. code:: python
+
+    from lifelines import AalenAdditiveFitter
+    from lifelines.datasets import load_dd
+
+    data = load_dd()
+    data.head()
+
+
+.. table::
+
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+    | ctryname  |cowcode2|politycode|un_region_name|un_continent_name|        ehead        |                     leaderspellreg                      |  democracy  |   regime    |start_year|duration|observed|
+    +===========+========+==========+==============+=================+=====================+=========================================================+=============+=============+==========+========+========+
+    |Afghanistan|     700|       700|Southern Asia |Asia             |Mohammad Zahir Shah  |Mohammad Zahir Shah.Afghanistan.1946.1952.Monarchy       |Non-democracy|Monarchy     |      1946|       7|       1|
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+    |Afghanistan|     700|       700|Southern Asia |Asia             |Sardar Mohammad Daoud|Sardar Mohammad Daoud.Afghanistan.1953.1962.Civilian Dict|Non-democracy|Civilian Dict|      1953|      10|       1|
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+    |Afghanistan|     700|       700|Southern Asia |Asia             |Mohammad Zahir Shah  |Mohammad Zahir Shah.Afghanistan.1963.1972.Monarchy       |Non-democracy|Monarchy     |      1963|      10|       1|
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+    |Afghanistan|     700|       700|Southern Asia |Asia             |Sardar Mohammad Daoud|Sardar Mohammad Daoud.Afghanistan.1973.1977.Civilian Dict|Non-democracy|Civilian Dict|      1973|       5|       0|
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+    |Afghanistan|     700|       700|Southern Asia |Asia             |Nur Mohammad Taraki  |Nur Mohammad Taraki.Afghanistan.1978.1978.Civilian Dict  |Non-democracy|Civilian Dict|      1978|       1|       0|
+    +-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+-------------+-------------+----------+--------+--------+
+
+
+
+We have also included the ``coef_penalizer`` option. During the estimation, a
+linear regression is computed at each step. Often the regression can be
+unstable (due to high co-linearity or small sample sizes) -- adding a penalizer term controls the stability. I recommend always starting with a small penalizer term -- if the estimates still appear to be too unstable, try increasing it.
+
+.. code:: python
+
+    aaf = AalenAdditiveFitter(coef_penalizer=1.0, fit_intercept=False)
+
+An instance of :class:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter`
+includes a :meth:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter.fit` method that performs the inference on the coefficients. This method accepts a pandas DataFrame: each row is an individual and columns are the covariates and
+two individual columns: a *duration* column and a boolean *event occurred* column (where event occurred refers to the event of interest - expulsion from government in this case)
+
+
+.. code:: python
+
+    data['T'] = data['duration']
+    data['E'] = data['observed']
+
+
+.. code:: python
+
+    aaf.fit(data, 'T', event_col='E', formula='un_continent_name + regime + start_year')
+
+
+After fitting, the instance exposes a :attr:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter.cumulative_hazards_` DataFrame
+containing the estimates of :math:`\int_0^t b_i(s) \; ds`:
+
+.. code:: python
+
+    aaf.cumulative_hazards_.head()
+
+
+.. table::
+
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+    |baseline|un_continent_name[T.Americas]|un_continent_name[T.Asia]|un_continent_name[T.Europe]|un_continent_name[T.Oceania]|regime[T.Military Dict]|regime[T.Mixed Dem]|regime[T.Monarchy]|regime[T.Parliamentary Dem]|regime[T.Presidential Dem]|start_year|
+    +========+=============================+=========================+===========================+============================+=======================+===================+==================+===========================+==========================+==========+
+    |-0.03447|                     -0.03173|                  0.06216|                     0.2058|                   -0.009559|                0.07611|            0.08729|           -0.1362|                    0.04885|                    0.1285|  0.000092|
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+    | 0.14278|                     -0.02496|                  0.11122|                     0.2083|                   -0.079042|                0.11704|            0.36254|           -0.2293|                    0.17103|                    0.1238|  0.000044|
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+    | 0.30153|                     -0.07212|                  0.10929|                     0.1614|                    0.063030|                0.16553|            0.68693|           -0.2738|                    0.33300|                    0.1499|  0.000004|
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+    | 0.37969|                      0.06853|                  0.15162|                     0.2609|                    0.185569|                0.22695|            0.95016|           -0.2961|                    0.37351|                    0.4311| -0.000032|
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+    | 0.36749|                      0.20201|                  0.21252|                     0.2429|                    0.188740|                0.25127|            1.15132|           -0.3926|                    0.54952|                    0.7593| -0.000000|
+    +--------+-----------------------------+-------------------------+---------------------------+----------------------------+-----------------------+-------------------+------------------+---------------------------+--------------------------+----------+
+
+
+
+:class:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter` also has built in plotting:
+
+.. code:: python
+
+  aaf.plot(columns=['regime[T.Presidential Dem]', 'Intercept', 'un_continent_name[T.Europe]'], iloc=slice(1,15))
+
+
+.. image:: images/survival_regression_aaf.png
+
+
+Regression is most interesting if we use it on data we have not yet
+seen, i.e., prediction! We can use what we have learned to predict
+individual hazard rates, survival functions, and median survival time.
+The dataset we are using is available up until 2008, so let's use this data to
+predict the duration of former Canadian
+Prime Minister Stephen Harper.
+
+.. code:: python
+
+    ix = (data['ctryname'] == 'Canada') & (data['start_year'] == 2006)
+    harper = data.loc[ix]
+    print("Harper's unique data point:")
+    print(harper)
+
+.. parsed-literal::
+
+    Harper's unique data point:
+         baseline  un_continent_name[T.Americas]  un_continent_name[T.Asia] ...  start_year  T  E
+    268       1.0                            1.0                        0.0 ...      2006.0  3  0
+
+
+.. code:: python
+
+    ax = plt.subplot(2,1,1)
+    aaf.predict_cumulative_hazard(harper).plot(ax=ax)
+
+    ax = plt.subplot(2,1,2)
+    aaf.predict_survival_function(harper).plot(ax=ax);
+
+
+.. image:: images/survival_regression_harper.png
+
+.. note:: Because of the nature of the model, estimated survival functions of individuals can increase. This is an expected artifact of Aalen's additive model.
+
+
+Model selection and calibration in survival regression
+==========================================================
+
+Parametric vs semi-parametric models
+---------------------------------------
+Above, we've displayed two *semi-parametric* models (Cox model and Aalen's model), and a family of *parametric* models. Which should you choose? What are the advantages and disadvantages of either? I suggest reading the two following StackExchange answers to get a better idea of what experts think:
+
+1. `In survival analysis, why do we use semi-parametric models (Cox proportional hazards) instead of fully parametric models? <https://stats.stackexchange.com/q/64739/11867>`__
+2. `In survival analysis, when should we use fully parametric models over semi-parametric ones? <https://stats.stackexchange.com/q/399544/11867>`__
+
+
+Model selection based on residuals
+-----------------------------------------------
+
+The sections `Testing the Proportional Hazard Assumptions`_ and `Assessing Cox model fit using residuals`_ may be useful for modeling your data better.
+
+.. note:: Work is being done to extend residual methods to all regression models. Stay tuned.
+
+
+Model selection based on predictive power and fit
+---------------------------------------------------
+
+If censoring is present, it's not appropriate to use a loss function like mean-squared-error or
+mean-absolute-loss. This is because the difference between a censored value and the predicted value could be due to poor prediction *or* due to censoring. Below we introduce alternative ways to measure prediction performance.
+
+Log-likelihood
+****************************
+
+
+In this author's opinion, the best way to measure predictive performance is evaluating the log-likelihood on out-of-sample data. The log-likelihood correctly handles any type of censoring, and is precisely what we are maximizing in the model training. The in-sample log-likelihood is available under ``log_likelihood_`` of any regression model. For out-of-sample data, the  :meth:`~lifelines.fitters.cox_ph_fitter.CoxPHFitter.score` method (available on all regression models) can be used. This returns the *average evaluation of the out-of-sample log-likelihood*. We want to maximize this.
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi().sample(frac=1.0, random_state=25)  # ensures the reproducibility of the example
+    train_rossi = rossi.iloc[:400]
+    test_rossi = rossi.iloc[400:]
+
+    cph_l1 = CoxPHFitter(penalizer=0.1, l1_ratio=1.).fit(train_rossi, 'week', 'arrest')
+    cph_l2 = CoxPHFitter(penalizer=0.1, l1_ratio=0.).fit(train_rossi, 'week', 'arrest')
+
+    print(cph_l1.score(test_rossi))
+    print(cph_l2.score(test_rossi))  # higher is better
+
+Akaike information criterion (AIC)
+*****************************************
+
+For within-sample validation, the AIC is a great metric for comparing models as it relies on the log-likelihood. It's available under ``AIC_`` for parametric models, and ``AIC_partial_`` for Cox models (because the Cox model maximizes a *partial* log-likelihood, it can't be reliably compared to parametric model's AIC.)
+
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    cph_l2 = CoxPHFitter(penalizer=0.1, l1_ratio=0.).fit(rossi, 'week', 'arrest')
+    cph_l1 = CoxPHFitter(penalizer=0.1, l1_ratio=1.).fit(rossi, 'week', 'arrest')
+
+    print(cph_l2.AIC_partial_) # lower is better
+    print(cph_l1.AIC_partial_)
+
+Concordance Index
+*****************************************
+
+
+Another censoring-sensitive measure is the concordance-index, also known as the c-index. This measure evaluates the accuracy of the *ranking* of predicted time. It is in fact a generalization of AUC, another common loss function, and is interpreted similarly:
+
+* 0.5 is the expected result from random predictions,
+* 1.0 is perfect concordance and,
+* 0.0 is perfect anti-concordance (multiply predictions with -1 to get 1.0)
+
+`Here <https://stats.stackexchange.com/a/478305/11867>`_ is an excellent introduction & description of the c-index for new users.
+
+Fitted survival models typically have a concordance index between 0.55 and 0.75 (this may seem bad, but even a perfect model has a lot of noise than can make a high score impossible). In *lifelines*, a fitted model's concordance-index is present in the output of :meth:`~lifelines.fitters.cox_ph_fitter.CoxPHFitter.score`, but also available under the ``concordance_index_`` property. Generally, the measure is implemented in *lifelines* under :meth:`lifelines.utils.concordance_index` and accepts the actual times (along with any censored subjects) and the predicted times.
+
+.. code:: python
+
+    from lifelines import CoxPHFitter
+    from lifelines.datasets import load_rossi
+
+    rossi = load_rossi()
+
+    cph = CoxPHFitter()
+    cph.fit(rossi, duration_col="week", event_col="arrest")
+
+    # fours ways to view the c-index:
+    # method one
+    cph.print_summary()
+
+    # method two
+    print(cph.concordance_index_)
+
+    # method three
+    print(cph.score(rossi, scoring_method="concordance_index"))
+
+    # method four
+    from lifelines.utils import concordance_index
+    print(concordance_index(rossi['week'], -cph.predict_partial_hazard(rossi), rossi['arrest']))
+
+.. note:: Remember, the concordance score evaluates the relative rankings of subject's event times. Thus, it is scale and shift invariant (i.e. you can multiple by a positive constant, or add a constant, and the rankings won't change). A model maximized for concordance-index does not necessarily give good predicted *times*, but will give good predicted *rankings*.
+
+
+Cross validation
+****************************
+
+*lifelines* has an implementation of k-fold cross validation under :func:`lifelines.utils.k_fold_cross_validation`. This function accepts an instance of a regression fitter (either :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter` of :class:`~lifelines.fitters.aalen_additive_fitter.AalenAdditiveFitter`), a dataset, plus ``k`` (the number of folds to perform, default 5). On each fold, it splits the data
+into a training set and a testing set fits itself on the training set and evaluates itself on the testing set (using the concordance measure by default).
+
+.. code:: python
+
+        from lifelines import CoxPHFitter
+        from lifelines.datasets import load_regression_dataset
+        from lifelines.utils import k_fold_cross_validation
+
+        regression_dataset = load_regression_dataset()
+        cph = CoxPHFitter()
+        scores = k_fold_cross_validation(cph, regression_dataset, 'T', event_col='E', k=3)
+        print(scores)
+        #[-2.9896, -3.08810, -3.02747]
+
+        scores = k_fold_cross_validation(cph, regression_dataset, 'T', event_col='E', k=3, scoring_method="concordance_index")
+        print(scores)
+        # [0.5449, 0.5587, 0.6179]
+
+Also, lifelines has wrappers for `compatibility with scikit learn`_ for making cross-validation and grid-search even easier.
+
+
+Model probability calibration
+---------------------------------------------------
+
+New in *lifelines* v0.24.11 is the :func:`~lifelines.calibration.survival_probability_calibration` function to measure your fitted survival model against observed frequencies of events. We follow the advice in "Graphical calibration curves and the integrated calibration index (ICI) for survival models" by P. Austin and co., and create a smoothed calibration curve using a flexible spline regression model (this avoids the traditional problem of binning the continuous-valued probability, and handles censored data).
+
+
+.. code:: python
+
+        from lifelines import CoxPHFitter
+        from lifelines.datasets import load_rossi
+        from lifelines.calibration import survival_probability_calibration
+
+        regression_dataset = load_rossi()
+        cph = CoxPHFitter(baseline_estimation_method="spline", n_baseline_knots=3)
+        cph.fit(rossi, "week", "arrest")
+
+
+        survival_probability_calibration(cph, rossi, t0=25)
+
+.. image:: images/survival_calibration_probablilty.png
+    :width: 600
+    :align: center
+
+
+Prediction on censored subjects
+===================================
+
+A common use case is to predict the event time of censored subjects. This is easy to do, but we first have to calculate an important conditional probability. Let :math:`T` be the (random) event time for some subject, and :math:`S(t)≔P(T > t)` be their survival function. We are interested in answering the following: *What is a subject's new survival function given I know the subject has lived past time :math:`s`?* Mathematically:
+
+.. math::
+
+    \begin{align*}
+    P(T > t \;|\; T > s) &= \frac{P(T > t \;\text{and}\; T > s)}{P(T > s)} \\
+                         &= \frac{P(T > t)}{P(T > s)} \\
+                         &= \frac{S(t)}{S(s)}
+    \end{align*}
+
+Thus we scale the original survival function by the survival function at time :math:`s` (everything prior to :math:`s` should be mapped to 1.0 as well, since we are working with probabilities and we know that the subject was alive before :math:`s`).
+
+This is such a common calculation that *lifelines* has all this built in. The ``conditional_after`` kwarg in all prediction methods
+allows you to specify what :math:`s` is per subject. Below we predict the remaining life of censored subjects:
+
+.. code:: python
+
+    # all regression models can be used here, WeibullAFTFitter is used for illustration
+    wf = WeibullAFTFitter().fit(rossi, "week", "arrest")
+
+    # filter down to just censored subjects to predict remaining survival
+    censored_subjects = rossi.loc[~rossi['arrest'].astype(bool)]
+    censored_subjects_last_obs = censored_subjects['week']
+
+    # predict new survival function
+    wf.predict_survival_function(censored_subjects, conditional_after=censored_subjects_last_obs)
+
+    # predict median remaining life
+    wf.predict_median(censored_subjects, conditional_after=censored_subjects_last_obs)
+
+.. note:: It's important to remember that this is now computing a *conditional* probability (or metric), so if the result of ``predict_median`` is 10.5, then the *entire lifetime* is 10.5 + ``conditional_after``.
+
+.. note:: If using ``conditional_after`` to predict on *uncensored* subjects, then ``conditional_after`` should probably be set to 0, or left blank.
+
+
+.. _Assessing Cox model fit using residuals: jupyter_notebooks/Cox%20residuals.html
+.. _Testing the Proportional Hazard Assumptions: jupyter_notebooks/Proportional%20hazard%20assumption.html
+.. _Custom Regression Models: jupyter_notebooks/Custom%20Regression%20Models.html
+.. _time varying model: Time%20varying%20survival%20regression.html
+.. _compatibility with scikit learn: Compatibility%20with%20scikit-learn.html

lifelines/source/docs/Survival analysis with lifelines.rst

@@ -0,0 +1,850 @@
+.. image:: https://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+Estimating univariate models
+=====================================
+
+In the previous :doc:`section</Survival Analysis intro>`,
+we introduced the applications of survival analysis and the
+mathematical objects on which it relies. In this article, we will work
+with real data and the *lifelines* library to estimate these objects.
+
+Estimating the survival function using Kaplan-Meier
+''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+For this example, we will be investigating the lifetimes of political
+leaders around the world. A political leader, in this case, is defined by a single individual's
+time in office who controls the ruling regime. This political leader could be an elected president,
+unelected dictator, monarch, etc. The birth event is the start of the individual's tenure, and the death
+event is the voluntary retirement of the individual. Censoring can occur if they are a) still in offices at the time
+of dataset compilation (2008), or b) die while in power (this includes assassinations).
+
+For example, the Bush regime began in 2000 and officially ended in 2008
+upon his retirement, thus the regime's lifespan was eight years, and there was a
+"death" event observed. On the other hand, the JFK regime lasted 2
+years, from 1961 and 1963, and the regime's official death event *was
+not* observed -- JFK died before his official retirement.
+
+(This is an example that has gladly redefined the birth and death
+events, and in fact completely flips the idea upside down by using deaths
+as the censoring event. This is also an example where the current time
+is not the only cause of censoring; there are the alternative events (e.g., death in office) that can
+be the cause of censoring.
+
+To estimate the survival function, we first will use the `Kaplan-Meier
+Estimate <http://en.wikipedia.org/wiki/Kaplan%E2%80%93Meier_estimator>`__,
+defined:
+
+.. math:: \hat{S}(t) = \prod_{t_i \lt t} \frac{n_i - d_i}{n_i}
+
+where :math:`d_i` are the number of death events at time :math:`t` and
+:math:`n_i` is the number of subjects at risk of death just prior to time
+:math:`t`.
+
+
+Let's bring in our dataset.
+
+.. code:: python
+
+    from lifelines.datasets import load_dd
+
+    data = load_dd()
+    data.head()
+
+
+
+.. table::
+
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+    |  democracy  |   regime    |start_year|duration|observed| ctryname  |cowcode2|politycode|un_region_name|un_continent_name|        ehead        |                     leaderspellreg                      |
+    +=============+=============+==========+========+========+===========+========+==========+==============+=================+=====================+=========================================================+
+    |Non-democracy|Monarchy     |      1946|       7|       1|Afghanistan|     700|       700|Southern Asia |Asia             |Mohammad Zahir Shah  |Mohammad Zahir Shah.Afghanistan.1946.1952.Monarchy       |
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+    |Non-democracy|Civilian Dict|      1953|      10|       1|Afghanistan|     700|       700|Southern Asia |Asia             |Sardar Mohammad Daoud|Sardar Mohammad Daoud.Afghanistan.1953.1962.Civilian Dict|
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+    |Non-democracy|Monarchy     |      1963|      10|       1|Afghanistan|     700|       700|Southern Asia |Asia             |Mohammad Zahir Shah  |Mohammad Zahir Shah.Afghanistan.1963.1972.Monarchy       |
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+    |Non-democracy|Civilian Dict|      1973|       5|       0|Afghanistan|     700|       700|Southern Asia |Asia             |Sardar Mohammad Daoud|Sardar Mohammad Daoud.Afghanistan.1973.1977.Civilian Dict|
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+    |Non-democracy|Civilian Dict|      1978|       1|       0|Afghanistan|     700|       700|Southern Asia |Asia             |Nur Mohammad Taraki  |Nur Mohammad Taraki.Afghanistan.1978.1978.Civilian Dict  |
+    +-------------+-------------+----------+--------+--------+-----------+--------+----------+--------------+-----------------+---------------------+---------------------------------------------------------+
+
+
+
+From the *lifelines* library, we'll need the
+:class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` for this exercise:
+
+.. code:: python
+
+    from lifelines import KaplanMeierFitter
+    kmf = KaplanMeierFitter()
+
+..  note:: Other ways to estimate the survival function in *lifelines* are discussed below.
+
+For this estimation, we need the duration each leader was/has been in
+office, and whether or not they were observed to have left office
+(leaders who died in office or were in office in 2008, the latest date
+this data was record at, do not have observed death events)
+
+We next use the :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` method :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit` to fit the model to
+the data. (This is similar to, and inspired by, scikit-learn's fit/predict API).
+
+Below we fit our data with the :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter`:
+
+
+.. code:: python
+
+    T = data["duration"]
+    E = data["observed"]
+
+    kmf.fit(T, event_observed=E)
+
+
+After calling the :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit` method, the :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` has a property
+called :attr:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.survival_function_` (again, we follow the styling of scikit-learn, and append an underscore to all properties that were estimated).
+The property is a Pandas DataFrame, so we can call :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.plot` on it:
+
+.. code:: python
+
+    from matplotlib import pyplot as plt
+
+
+    kmf.survival_function_.plot()
+    plt.title('Survival function of political regimes');
+
+.. image:: images/lifelines_intro_kmf_curve.png
+    :width: 600px
+    :align: center
+
+How do we interpret this? The y-axis represents the probability a leader is still
+around after :math:`t` years, where :math:`t` years is on the x-axis. We
+see that very few leaders make it past 20 years in office. Of course, we need to report how uncertain we are about these point estimates, i.e., we need confidence intervals. They are computed in
+the call to :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit`, and located under the :attr:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.confidence_interval_`
+property. (The method uses exponential Greenwood confidence interval. The mathematics are found in `these notes <https://www.math.wustl.edu/%7Esawyer/handouts/greenwood.pdf>`_.) We can call :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.plot` on the :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` itself to plot both the KM estimate and its confidence intervals:
+
+.. code:: python
+
+    kmf.plot_survival_function()
+
+.. image:: images/lifelines_intro_kmf_fitter.png
+    :width: 600px
+    :align: center
+
+The median time in office, which defines the point in time where on
+average 50% of the population has expired, is a property:
+
+.. code:: python
+
+    kmf.median_survival_time_
+    #   4.0
+
+
+Interesting that it is only four years. That means, around the world, elected leaders
+have a 50% chance of cessation in four years or less! To get the confidence interval of the median, you can use:
+
+.. code:: python
+
+    from lifelines.utils import median_survival_times
+    median_ci = median_survival_times(kmf.confidence_interval_)
+
+
+Let's segment on democratic regimes vs non-democratic regimes. Calling
+``plot`` on either the estimate itself or the fitter object will return
+an ``axis`` object, that can be used for plotting further estimates:
+
+.. code:: python
+
+    ax = plt.subplot(111)
+
+    dem = (data["democracy"] == "Democracy")
+
+    kmf.fit(T[dem], event_observed=E[dem], label="Democratic Regimes")
+    kmf.plot_survival_function(ax=ax)
+
+    kmf.fit(T[~dem], event_observed=E[~dem], label="Non-democratic Regimes")
+    kmf.plot_survival_function(ax=ax)
+
+    plt.title("Lifespans of different global regimes");
+
+
+.. image:: images/lifelines_intro_multi_kmf_fitter.png
+    :width: 650px
+    :align: center
+
+We might be interested in estimating the probabilities in between some
+points. We can do that with the ``timeline`` argument. We specify the
+times we are interested in and are returned a DataFrame with the
+probabilities of survival at those points:
+
+.. code:: python
+
+    import numpy as np
+
+    ax = plt.subplot(111)
+
+    t = np.linspace(0, 50, 51)
+    kmf.fit(T[dem], event_observed=E[dem], timeline=t, label="Democratic Regimes")
+    ax = kmf.plot_survival_function(ax=ax)
+
+    kmf.fit(T[~dem], event_observed=E[~dem], timeline=t, label="Non-democratic Regimes")
+    ax = kmf.plot_survival_function(ax=ax)
+
+    plt.title("Lifespans of different global regimes");
+
+.. image:: images/lifelines_intro_multi_kmf_fitter_2.png
+    :width: 650px
+    :align: center
+
+It is incredible how much longer these non-democratic regimes exist for.
+A democratic regime does have a natural bias towards death though: both
+via elections and natural limits (the US imposes a strict eight-year limit).
+The median of a non-democratic is only about twice as large as a
+democratic regime, but the difference is apparent in the tails:
+if you're a non-democratic leader, and you've made it past the 10 year
+mark, you probably have a long life ahead. Meanwhile, a democratic
+leader rarely makes it past ten years, and then have a very short
+lifetime past that.
+
+
+Here the difference between survival functions is very obvious, and
+performing a statistical test seems pedantic. If the curves are more
+similar, or we possess less data, we may be interested in performing a
+statistical test. In this case, *lifelines* contains routines in
+:mod:`lifelines.statistics` to compare two survival functions. Below we
+demonstrate this routine. The function :func:`lifelines.statistics.logrank_test` is a common
+statistical test in survival analysis that compares two event series'
+generators. If the value returned exceeds some pre-specified value, then
+we rule that the series have different generators.
+
+.. code:: python
+
+    from lifelines.statistics import logrank_test
+
+    results = logrank_test(T[dem], T[~dem], E[dem], E[~dem], alpha=.99)
+
+    results.print_summary()
+
+    """
+    <lifelines.StatisticalResult>
+                 t_0 = -1
+    null_distribution = chi squared
+    degrees_of_freedom = 1
+               alpha = 0.99
+
+    ---
+    test_statistic      p  -log2(p)
+           260.47  <0.005    192.23
+    """
+
+There are alternative (and sometimes better) tests of survival functions, and we explain more here: `Statistically compare two populations <https://github.com/CamDavidsonPilon/lifelines/blob/master/docs/Examples.rst#statistically-compare-two-populations>`_
+
+
+Lets compare the different *types* of regimes present in the dataset:
+
+.. code:: python
+
+    regime_types = data['regime'].unique()
+
+    for i, regime_type in enumerate(regime_types):
+        ax = plt.subplot(2, 3, i + 1)
+
+        ix = data['regime'] == regime_type
+        kmf.fit(T[ix], E[ix], label=regime_type)
+        kmf.plot_survival_function(ax=ax, legend=False)
+
+        plt.title(regime_type)
+        plt.xlim(0, 50)
+
+        if i==0:
+            plt.ylabel('Frac. in power after $n$ years')
+
+    plt.tight_layout()
+
+
+.. image:: images/lifelines_intro_all_regimes.png
+    :align: center
+    :width: 700px
+
+Best practices for presenting Kaplan Meier plots
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A recent survey of statisticians, medical professionals, and other stakeholders suggested that the addition
+of two pieces of information, summary tables and confidence intervals, greatly increased the effectiveness of Kaplan Meier plots, see "Morris TP, Jarvis CI, Cragg W, et al. Proposals on Kaplan–Meier plots in medical research and a survey of stakeholder views: KMunicate. BMJ Open 2019;9:e030215. doi:10.1136/bmjopen-2019-030215".
+
+In *lifelines*, confidence intervals are automatically added, but there is the ``at_risk_counts`` kwarg to add summary tables as well:
+
+.. code:: python
+
+    kmf = KaplanMeierFitter().fit(T, E, label="all_regimes")
+    kmf.plot_survival_function(at_risk_counts=True)
+    plt.tight_layout()
+
+
+
+.. image:: images/intro_add_at_risk.png
+    :align: center
+    :width: 700px
+
+For more details, and how to extend this to multiple curves, see `docs here <https://lifelines.readthedocs.io/en/latest/Examples.html#displaying-multiple-at-risk-counts-below-plots>`_.
+
+Getting data into the right format
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+*lifelines* data format is consistent across all estimator class and
+functions: an array of individual durations, and the individuals
+event observation (if any). These are often denoted ``T`` and ``E``
+respectively. For example:
+
+::
+
+    T = [0, 3, 3, 2, 1, 2]
+    E = [1, 1, 0, 0, 1, 1]
+    kmf.fit(T, event_observed=E)
+
+The raw data is not always available in this format -- *lifelines*
+includes some helper functions to transform data formats to *lifelines*
+format. These are located in the :mod:`lifelines.utils` sub-library. For
+example, the function :func:`~lifelines.utils.datetimes_to_durations` accepts an array or
+Pandas object of start times/dates, and an array or Pandas objects of
+end times/dates (or ``None`` if not observed):
+
+.. code:: python
+
+    from lifelines.utils import datetimes_to_durations
+
+    start_date = ['2013-10-10 0:00:00', '2013-10-09', '2013-10-10']
+    end_date = ['2013-10-13', '2013-10-10', None]
+    T, E = datetimes_to_durations(start_date, end_date, fill_date='2013-10-15')
+    print('T (durations): ', T)
+    print('E (event_observed): ', E)
+
+.. parsed-literal::
+
+    T (durations):  [ 3.  1.  5.]
+    E (event_observed):  [ True  True False]
+
+
+The function :func:`~lifelines.utils.datetimes_to_durations` is very flexible, and has many
+keywords to tinker with.
+
+
+Estimating hazard rates using Nelson-Aalen
+''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+The survival functions is a great way to summarize and visualize the
+survival dataset, however it is not the only way. If we are curious about the hazard function :math:`h(t)` of a
+population, we unfortunately cannot transform the Kaplan Meier estimate
+-- statistics doesn't work quite that well. Fortunately, there is a
+proper non-parametric estimator of the *cumulative* hazard function, :math:`H(t)`:
+
+.. math::  \text{Let} H(t) =  \int_0^t \h(z) \;dz
+
+
+
+The estimator for this quantity is called the Nelson Aalen estimator:
+
+
+
+.. math:: \hat{H}(t) = \sum_{t_i \le t} \frac{d_i}{n_i}
+
+where :math:`d_i` is the number of deaths at time :math:`t_i` and
+:math:`n_i` is the number of susceptible individuals.
+
+In *lifelines*, this estimator is available as the :class:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter`. Let's use the regime dataset from above:
+
+.. code:: python
+
+    T = data["duration"]
+    E = data["observed"]
+
+    from lifelines import NelsonAalenFitter
+    naf = NelsonAalenFitter()
+
+    naf.fit(T,event_observed=E)
+
+
+After fitting, the class exposes the property :meth:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter.cumulative_hazard_`` as
+a DataFrame:
+
+.. code:: python
+
+    print(naf.cumulative_hazard_.head())
+    naf.plot_cumulative_hazard()
+
+.. parsed-literal::
+
+       NA-estimate
+    0     0.000000
+    1     0.325912
+    2     0.507356
+    3     0.671251
+    4     0.869867
+
+    [5 rows x 1 columns]
+
+
+
+.. image:: images/lifelines_intro_naf_fitter.png
+    :width: 650px
+    :align: center
+
+The cumulative hazard has less obvious understanding than the survival
+functions, but the hazard functions is the basis of more advanced techniques in
+survival analysis. Recall that we are estimating *cumulative hazard
+functions*, :math:`H(t)`. (Why? The sum of estimates is much more
+stable than the point-wise estimates.) Thus we know the *rate of change*
+of this curve is an estimate of the hazard function.
+
+Looking at figure above, it looks like the hazard starts off high and
+gets smaller (as seen by the decreasing rate of change). Let's break the
+regimes down between democratic and non-democratic, during the first 20
+years:
+
+.. note::  We are using the ``loc`` argument in the call to ``plot_cumulative_hazard`` here: it accepts a ``slice`` and plots only points within that slice.
+
+.. code:: python
+
+    naf.fit(T[dem], event_observed=E[dem], label="Democratic Regimes")
+    ax = naf.plot_cumulative_hazard(loc=slice(0, 20))
+
+    naf.fit(T[~dem], event_observed=E[~dem], label="Non-democratic Regimes")
+    naf.plot_cumulative_hazard(ax=ax, loc=slice(0, 20))
+
+    plt.title("Cumulative hazard function of different global regimes");
+
+
+.. image:: images/lifelines_intro_naf_fitter_multi.png
+    :width: 600px
+    :align: center
+
+Looking at the rates of change, I would say that both political
+philosophies have a constant hazard, albeit democratic regimes have a
+much *higher* constant hazard.
+
+Smoothing the hazard function
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Interpretation of the cumulative hazard function can be difficult -- it
+is not how we usually interpret functions. On the other hand, most
+survival analysis is done using the cumulative hazard function, so understanding
+it is recommended.
+
+Alternatively, we can derive the more interpretable hazard function, but
+there is a catch. The derivation involves a kernel smoother (to smooth
+out the differences of the cumulative hazard function) , and this requires
+us to specify a bandwidth parameter that controls the amount of
+smoothing. This functionality is in the :meth:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter.smoothed_hazard_`
+and :meth:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter.smoothed_hazard_confidence_intervals_` methods. Why methods?
+They require an argument representing the bandwidth.
+
+
+There is also a :meth:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter.plot_hazard` function (that also requires a
+``bandwidth`` keyword) that will plot the estimate plus the confidence
+intervals, similar to the traditional :meth:`~lifelines.fitters.nelson_aalen_fitter.NelsonAalenFitter.plot` functionality.
+
+.. code:: python
+
+    bandwidth = 3.
+
+    naf.fit(T[dem], event_observed=E[dem], label="Democratic Regimes")
+    ax = naf.plot_hazard(bandwidth=bandwidth)
+
+    naf.fit(T[~dem], event_observed=E[~dem], label="Non-democratic Regimes")
+    naf.plot_hazard(ax=ax, bandwidth=bandwidth)
+
+    plt.title("Hazard function of different global regimes | bandwidth=%.1f" % bandwidth);
+    plt.ylim(0, 0.4)
+    plt.xlim(0, 25);
+
+
+.. image:: images/lifelines_intro_naf_smooth_multi.png
+    :width: 600px
+    :align: center
+
+It is more clear here which group has the higher hazard, and Non-democratic regimes appear to have a constant hazard.
+
+There is no obvious way to choose a bandwidth, and different
+bandwidths produce different inferences, so it's best to be very careful
+here. My advice: stick with the cumulative hazard function.
+
+.. code:: python
+
+    bandwidth = 8.0
+
+    naf.fit(T[dem], event_observed=E[dem], label="Democratic Regimes")
+    ax = naf.plot_hazard(bandwidth=bandwidth)
+
+    naf.fit(T[~dem], event_observed=E[~dem], label="Non-democratic Regimes")
+    naf.plot_hazard(ax=ax, bandwidth=bandwidth)
+
+    plt.title("Hazard function of different global regimes | bandwidth=%.1f" % bandwidth);
+
+
+
+.. image:: images/lifelines_intro_naf_smooth_multi_2.png
+    :width: 600px
+    :align: center
+
+Estimating cumulative hazards using parametric models
+''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+
+Fitting to a Weibull model
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Another very popular model for survival data is the Weibull model. In contrast the the Nelson-Aalen estimator, this model is a *parametric model*, meaning it has a functional form with parameters that we are fitting the data to. (The Nelson-Aalen estimator has no parameters to fit to). The survival function looks like:
+
+
+.. math::  S(t) = \exp\left(-\left(\frac{t}{\lambda}\right)^\rho\right),   \lambda >0, \rho > 0,
+
+A priori, we do not know what :math:`\lambda` and :math:`\rho` are, but we use the data on hand to estimate these parameters. We model and estimate the cumulative hazard rate instead of the survival function (this is different than the Kaplan-Meier estimator):
+
+.. math::  H(t) = \left(\frac{t}{\lambda}\right)^\rho
+
+In lifelines, estimation is available using the :class:`~lifelines.fitters.weibull_fitter.WeibullFitter` class. The :meth:`~lifelines.fitters.weibull_fitter.WeibullFitter.plot` method will plot the cumulative hazard.
+
+.. code:: python
+
+    from lifelines import WeibullFitter
+    from lifelines.datasets import load_waltons
+
+    data = load_waltons()
+
+    T = data['T']
+    E = data['E']
+
+    wf = WeibullFitter().fit(T, E)
+
+    wf.print_summary()
+    ax = wf.plot_cumulative_hazard()
+    ax.set_title("Cumulative hazard of Weibull model; estimated parameters")
+
+
+    """
+    <lifelines.WeibullFitter: fitted with 163 observations, 7 censored>
+    number of subjects = 163
+      number of events = 156
+        log-likelihood = -672.062
+            hypothesis = lambda != 1, rho != 1
+
+    ---
+             coef  se(coef)  lower 0.95  upper 0.95      p  -log2(p)
+    lambda_  0.02      0.00        0.02        0.02 <0.005       inf
+    rho_     3.45      0.24        2.97        3.93 <0.005     76.83
+    """
+
+.. image:: images/survival_weibull.png
+    :width: 550px
+    :align: center
+
+
+Other parametric models: Exponential, Log-Logistic, Log-Normal and Splines
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Similarly, there are other parametric models in *lifelines*. Generally, which parametric model to choose is determined by either knowledge of the distribution of durations, or some sort of model goodness-of-fit. Below are the built-in parametric models, and the Nelson-Aalen non-parametric model, of the same data.
+
+.. code:: python
+
+    from lifelines import (WeibullFitter, ExponentialFitter,
+    LogNormalFitter, LogLogisticFitter, NelsonAalenFitter,
+    PiecewiseExponentialFitter, GeneralizedGammaFitter, SplineFitter)
+
+    from lifelines.datasets import load_waltons
+    data = load_waltons()
+
+    fig, axes = plt.subplots(3, 3, figsize=(10, 7.5))
+
+    T = data['T']
+    E = data['E']
+
+    wbf = WeibullFitter().fit(T, E, label='WeibullFitter')
+    exf = ExponentialFitter().fit(T, E, label='ExponentialFitter')
+    lnf = LogNormalFitter().fit(T, E, label='LogNormalFitter')
+    naf = NelsonAalenFitter().fit(T, E, label='NelsonAalenFitter')
+    llf = LogLogisticFitter().fit(T, E, label='LogLogisticFitter')
+    pwf = PiecewiseExponentialFitter([40, 60]).fit(T, E, label='PiecewiseExponentialFitter')
+    gg = GeneralizedGammaFitter().fit(T, E, label='GeneralizedGammaFitter')
+    spf = SplineFitter([6, 20, 40, 75]).fit(T, E, label='SplineFitter')
+
+    wbf.plot_cumulative_hazard(ax=axes[0][0])
+    exf.plot_cumulative_hazard(ax=axes[0][1])
+    lnf.plot_cumulative_hazard(ax=axes[0][2])
+    naf.plot_cumulative_hazard(ax=axes[1][0])
+    llf.plot_cumulative_hazard(ax=axes[1][1])
+    pwf.plot_cumulative_hazard(ax=axes[1][2])
+    gg.plot_cumulative_hazard(ax=axes[2][0])
+    spf.plot_cumulative_hazard(ax=axes[2][1])
+
+
+.. image:: images/waltons_cumulative_hazard.png
+
+*lifelines* can also be used to define your own parametric model. There is a tutorial on this available, see `Piecewise Exponential Models and Creating Custom Models`_.
+
+Parametric models can also be used to create and plot the survival function, too. Below we compare the parametric models versus the non-parametric Kaplan-Meier estimate:
+
+.. code:: python
+
+    from lifelines import KaplanMeierFitter
+
+    fig, axes = plt.subplots(3, 3, figsize=(10, 7.5))
+
+    T = data['T']
+    E = data['E']
+
+    kmf = KaplanMeierFitter().fit(T, E, label='KaplanMeierFitter')
+    wbf = WeibullFitter().fit(T, E, label='WeibullFitter')
+    exf = ExponentialFitter().fit(T, E, label='ExponentialFitter')
+    lnf = LogNormalFitter().fit(T, E, label='LogNormalFitter')
+    llf = LogLogisticFitter().fit(T, E, label='LogLogisticFitter')
+    pwf = PiecewiseExponentialFitter([40, 60]).fit(T, E, label='PiecewiseExponentialFitter')
+    gg = GeneralizedGammaFitter().fit(T, E, label='GeneralizedGammaFitter')
+    spf = SplineFitter([6, 20, 40, 75]).fit(T, E, label='SplineFitter')
+
+    wbf.plot_survival_function(ax=axes[0][0])
+    exf.plot_survival_function(ax=axes[0][1])
+    lnf.plot_survival_function(ax=axes[0][2])
+    kmf.plot_survival_function(ax=axes[1][0])
+    llf.plot_survival_function(ax=axes[1][1])
+    pwf.plot_survival_function(ax=axes[1][2])
+    gg.plot_survival_function(ax=axes[2][0])
+    spf.plot_survival_function(ax=axes[2][1])
+
+.. image:: images/waltons_survival_function.png
+
+With parametric models, we have a functional form that allows us to extend the survival function (or hazard or cumulative hazard) past our maximum observed duration. This is called extrapolation. We can do this in a few ways.
+
+.. code:: python
+
+    timeline = np.linspace(0, 100, 200)
+
+    # directly compute the survival function, these return a pandas Series
+    wbf = WeibullFitter().fit(T, E)
+    wbf.survival_function_at_times(timeline)
+    wbf.hazard_at_times(timeline)
+    wbf.cumulative_hazard_at_times(timeline)
+
+    # use the `timeline` kwarg in `fit`
+    # by default, all functions and properties will use
+    # these values provided
+    wbf = WeibullFitter().fit(T, E, timeline=timeline)
+
+    ax = wbf.plot_survival_function()
+    ax.set_title("Survival function of Weibull model; estimated parameters")
+
+.. image:: images/weibull_extrapolation.png
+    :width: 600px
+    :align: center
+
+Model Selection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When the underlying data generation distribution is unknown, we resort to measures of fit to tell us which model is most appropriate. *lifelines* has provided qq-plots, `Selecting a parametric model using QQ plots`_, and also tools to compare AIC and other measures: `Selecting a parametric model using AIC`_.
+
+
+Other types of censoring
+''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+Left censored data and non-detection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We've mainly been focusing on *right-censoring*, which describes cases where we do not observe the death event.
+This situation is the most common one. Alternatively, there are situations where we do not observe the *birth* event
+occurring. Consider the case where a doctor sees a delayed onset of symptoms of an underlying disease. The doctor
+is unsure *when* the disease was contracted (birth), but knows it was before the discovery.
+
+Another situation where we have left-censored data is when measurements have only an upper bound, that is, the measurements
+instruments could only detect the measurement was *less* than some upper bound. This bound is often called the limit of detection (LOD). In practice, there could be more than one LOD. One very important statistical lesson: don't "fill-in" this value naively. It's tempting to use something like one-half the LOD, but this will cause *lots* of bias in downstream analysis. An example dataset is below:
+
+.. note:: The recommended API for modeling left-censored data using parametric models changed in version 0.21.0. Below is the recommended API.
+
+.. code:: python
+
+    from lifelines.datasets import load_nh4
+    df = load_nh4()[['NH4.Orig.mg.per.L', 'NH4.mg.per.L', 'Censored']]
+    print(df.head())
+
+    """
+      NH4.Orig.mg.per.L  NH4.mg.per.L  Censored
+    1            <0.006         0.006      True
+    2            <0.006         0.006      True
+    3             0.006         0.006     False
+    4             0.016         0.016     False
+    5            <0.006         0.006      True
+    """
+
+
+*lifelines* has support for left-censored datasets in most univariate models, including the :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` class, by using the :meth:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.fit_left_censoring` method.
+
+.. code:: python
+
+
+    T, E = df['NH4.mg.per.L'], ~df['Censored']
+
+    kmf = KaplanMeierFitter()
+    kmf.fit_left_censoring(T, E)
+
+Instead of producing a survival function, left-censored data analysis is more interested in the cumulative density function. This is available as the :attr:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter.cumulative_density_` property after fitting the data.
+
+.. code:: python
+
+    print(kmf.cumulative_density_.head())
+
+    kmf.plot_cumulative_density() #will plot the CDF
+    plt.xlabel("Concentration of NH_4")
+
+    """
+              KM_estimate
+    timeline
+    0.000        0.379897
+    0.006        0.401002
+    0.007        0.464319
+    0.008        0.478828
+    0.009        0.536868
+    """
+
+
+.. image:: images/lifelines_intro_lcd.png
+    :width: 600px
+    :align: center
+
+Alternatively, you can use a parametric model to model the data. This allows for you to "peer" below the LOD, however using a parametric model means you need to correctly specify the distribution. You can use plots like qq-plots to help invalidate some distributions, see `Selecting a parametric model using QQ plots`_ and `Selecting a parametric model using AIC`_.
+
+
+.. code:: python
+
+    from lifelines import *
+    from lifelines.plotting import qq_plot
+
+    fig, axes = plt.subplots(3, 2, figsize=(9, 9))
+    timeline = np.linspace(0, 0.25, 100)
+
+    wf = WeibullFitter().fit_left_censoring(T, E, label="Weibull", timeline=timeline)
+    lnf = LogNormalFitter().fit_left_censoring(T, E, label="Log Normal", timeline=timeline)
+    lgf = LogLogisticFitter().fit_left_censoring(T, E, label="Log Logistic", timeline=timeline)
+
+    # plot what we just fit, along with the KMF estimate
+    kmf.plot_cumulative_density(ax=axes[0][0], ci_show=False)
+    wf.plot_cumulative_density(ax=axes[0][0], ci_show=False)
+    qq_plot(wf, ax=axes[0][1])
+
+    kmf.plot_cumulative_density(ax=axes[1][0], ci_show=False)
+    lnf.plot_cumulative_density(ax=axes[1][0], ci_show=False)
+    qq_plot(lnf, ax=axes[1][1])
+
+    kmf.plot_cumulative_density(ax=axes[2][0], ci_show=False)
+    lgf.plot_cumulative_density(ax=axes[2][0], ci_show=False)
+    qq_plot(lgf, ax=axes[2][1])
+
+.. image:: images/lcd_parametric.png
+
+
+Based on the above, the log-normal distribution seems to fit well, and the Weibull not very well at all.
+
+
+Interval censored data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Data can also be *interval* censored. An example of this is periodically recording a population of organisms. Their deaths are interval censored because you know a subject died between two observations periods.
+
+
+.. code:: python
+
+
+    from lifelines.datasets import load_diabetes
+    from lifelines.plotting import plot_interval_censored_lifetimes
+
+    df = load_diabetes()
+    plot_interval_censored_lifetimes(df['left'], df['right'])
+
+.. image:: images/interval_censored_lifetimes.png
+    :width: 670px
+    :align: center
+
+
+Above, we can see that some subjects' death was exactly observed (denoted by a red ●), and some subjects' deaths is bounded between two times (denoted by the interval between the red ▶︎ ◀︎).  We can perform inference on the data using any of our models. Note the use of calling ``fit_interval_censoring`` instead of ``fit``.
+
+.. note:: The API for ``fit_interval_censoring`` is different than right and left censored data.
+
+.. code:: python
+
+    wf = WeibullFitter()
+    wf.fit_interval_censoring(lower_bound=df['left'], upper_bound=df['right'])
+
+    # or, a non-parametric estimator:
+    # for now, this assumes closed observation intervals, ex: [4,5], not (4, 5) or (4, 5]
+    kmf = KaplanMeierFitter()
+    kmf.fit_interval_censoring(df['left'], df['right'])
+
+    ax = kmf.plot_survival_function()
+    wf.plot_survival_function(ax=ax)
+
+
+.. image:: images/interval_censored_inference.png
+    :width: 670px
+    :align: center
+
+
+
+Another example of using lifelines for interval censored data is located `here <https://dataorigami.net/blogs/napkin-folding/counting-and-interval-censoring>`_.
+
+
+
+Left truncated (late entry) data
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Another form of bias that is introduced into a dataset is called left-truncation (or late entry). Left-truncation can occur in many situations. One situation is when individuals may have the opportunity to die before entering into the study. For example, if you are measuring time to death of prisoners in prison, the prisoners will enter the study at different ages. So it's possible there are some counter-factual individuals who *would* have entered into your study (that is, went to prison), but instead died early.
+
+All fitters, like :class:`~lifelines.fitters.kaplan_meier_fitter.KaplanMeierFitter` and any parametric models, have an optional argument for ``entry``, which is an array of equal size to the duration array. It describes the time between actual "birth" (or "exposure") to entering the study.
+
+ .. note:: Nothing changes in the duration array: it still measures time from "birth" to time exited study (either by death or censoring). That is, durations refers to the absolute death time rather than a duration relative to the study entry.
+
+Another situation with left-truncation occurs when subjects are exposed before entry into study. For example, a study of time to all-cause mortality of AIDS patients that recruited individuals previously diagnosed with AIDS, possibly years before. In our example below we will use a dataset like this, called the Multicenter Aids Cohort Study. In the figure below, we plot the lifetimes of subjects. A solid line is when the subject was under our observation, and a dashed line represents the unobserved period between diagnosis and study entry. A solid dot at the end of the line represents death.
+
+.. code:: python
+
+    from lifelines.datasets import load_multicenter_aids_cohort_study
+    from lifelines.plotting import plot_lifetimes
+
+    df = load_multicenter_aids_cohort_study()
+
+    plot_lifetimes(
+        df["T"],
+        event_observed=df["D"],
+        entry=df["W"],
+        event_observed_color="#383838",
+        event_censored_color="#383838",
+        left_truncated=True,
+    )
+    plt.ylabel("Patient Number")
+    plt.xlabel("Years from AIDS diagnosis")
+
+
+.. image:: images/lifetimes_mcas.png
+    :width: 670px
+    :align: center
+
+So subject #77, the subject at the top, was diagnosed with AIDS 7.5 years ago, but wasn't in our study for the first 4.5 years. From this point-of-view, why can't we "fill in" the dashed lines and say, for example, "subject #77 lived for 7.5 years"? If we did this, we would severely underestimate chance of dying early on after diagnosis. Why? It's possible that there were individuals who were diagnosed and then died shortly after, and never had a chance to enter our study. If we did manage to observe them however, they would have depressed the survival function early on. Thus, "filling in" the dashed lines makes us over confident about what occurs in the early period after diagnosis. We can see this below when we model the survival function with and without taking into account late entries.
+
+
+.. code:: python
+
+        from lifelines import KaplanMeierFitter
+
+        kmf = KaplanMeierFitter()
+        kmf.fit(df["T"], event_observed=df["D"], entry=df["W"], label='modeling late entries')
+        ax = kmf.plot_survival_function()
+
+        kmf.fit(df["T"], event_observed=df["D"], label='ignoring late entries')
+        kmf.plot_survival_function(ax=ax)
+
+
+.. image:: images/kmf_mcas.png
+    :width: 650px
+    :align: center
+
+
+.. _Piecewise Exponential Models and Creating Custom Models: jupyter_notebooks/Piecewise%20Exponential%20Models%20and%20Creating%20Custom%20Models.html
+.. _Statistically compare two populations: Examples.html#statistically-compare-two-populations
+.. _Selecting a parametric model using QQ plots: Examples.html#selecting-a-parametric-model-using-qq-plots
+.. _Selecting a parametric model using AIC: Examples.html#selecting-a-parametric-model-using-AIC

lifelines/source/docs/Time varying survival regression.rst

@@ -0,0 +1,262 @@
+
+Time varying survival regression
+=====================================
+
+Cox's time varying proportional hazard model
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Often an individual will have a covariate change over time. An example of this is hospital patients who enter the study and, at some future time, may receive a heart transplant. We would like to know the effect of the transplant, but we must be careful if we condition on whether they received the transplant. Consider that if patients needed to wait at least 1 year before getting a transplant, then everyone who dies before that year is considered as a non-transplant patient, and hence this would overestimate the hazard of not receiving a transplant.
+
+We can incorporate changes over time into our survival analysis by using a modification of the Cox model. The general mathematical description is:
+
+.. math::  h(t | x) = \overbrace{b_0(t)}^{\text{baseline}}\underbrace{\exp \overbrace{\left(\sum_{i=1}^n \beta_i (x_i(t) - \overline{x_i}) \right)}^{\text{log-partial hazard}}}_ {\text{partial hazard}}
+
+Note the time-varying :math:`x_i(t)` to denote that covariates can change over time. This model is implemented in *lifelines* as :class:`~lifelines.fitters.cox_time_varying_fitter.CoxTimeVaryingFitter`. The dataset schema required is different than previous models, so we will spend some time describing it.
+
+Dataset creation for time-varying regression
+#############################################
+
+*lifelines* requires that the dataset be in what is called the *long* format. This looks like one row per state change, including an ID, the left (exclusive) time point, and right (inclusive) time point. For example, the following dataset tracks three unique subjects.
+
+.. table::
+
+    +--+-----+----+-----+-+-----+
+    |id|start|stop|group|z|event|
+    +==+=====+====+=====+=+=====+
+    | 1|    0|   8|    1|0|False|
+    +--+-----+----+-----+-+-----+
+    | 2|    0|   5|    0|0|False|
+    +--+-----+----+-----+-+-----+
+    | 2|    5|   8|    0|1|True |
+    +--+-----+----+-----+-+-----+
+    | 3|    0|   3|    1|0|False|
+    +--+-----+----+-----+-+-----+
+    | 3|    3|  12|    1|1|True |
+    +--+-----+----+-----+-+-----+
+
+
+In the above dataset, ``start`` and ``stop`` denote the boundaries, ``id`` is the unique identifier per subject, and ``event`` denotes if the subject died at the end of that period. For example, subject ID 2 had variable ``z=0`` up to and including the end of time period 5 (we can think that measurements happen at end of the time period), after which it was set to 1. Since ``event`` is 1 in that row, we conclude that the subject died at time 8,
+
+This desired dataset can be built up from smaller datasets. To do this we can use some helper functions provided in *lifelines*. Typically, data will be in a format that looks like it comes out of a relational database. You may have a "base" table with ids, durations alive, and a censored flag, and possibly static covariates. Ex:
+
+.. table::
+
+    +--+--------+-----+----+
+    |id|duration|event|var1|
+    +==+========+=====+====+
+    | 1|      10|True | 0.1|
+    +--+--------+-----+----+
+    | 2|      12|False| 0.5|
+    +--+--------+-----+----+
+
+
+We will perform a light transform to this dataset to modify it into the "long" format.
+
+.. code:: python
+
+      import pandas as pd
+      from lifelines.utils import to_long_format
+
+      base_df = pd.DataFrame([
+        {'id': 1, 'duration': 10, 'event': True, 'var1': 0.1},
+        {'id': 2, 'duration': 12, 'event': True, 'var1': 0.5}
+      ])
+
+      base_df = to_long_format(base_df, duration_col="duration")
+
+The new dataset looks like:
+
+
+.. table::
+
+    +--+-----+----+----+-----+
+    |id|start|stop|var1|event|
+    +==+=====+====+====+=====+
+    | 1|    0|  10| 0.1|True |
+    +--+-----+----+----+-----+
+    | 2|    0|  12| 0.5|False|
+    +--+-----+----+----+-----+
+
+
+You'll also have secondary dataset that references future measurements. This could come in two "types". The first is when you have a variable that changes over time (ex: administering varying medication over time, or taking a temperature over time). The second types is an event-based dataset: an event happens at some time in the future (ex: an organ transplant occurs, or an intervention). We will address this second type later. The first type of dataset may look something like:
+
+Example:
+
+.. table::
+
+    +--+----+----+
+    |id|time|var2|
+    +==+====+====+
+    | 1|   0| 1.4|
+    +--+----+----+
+    | 1|   4| 1.2|
+    +--+----+----+
+    | 1|   8| 1.5|
+    +--+----+----+
+    | 2|   0| 1.6|
+    +--+----+----+
+
+where ``time`` is the duration from the entry event. Here we see subject 1 had a change in their ``var2`` covariate at the end of time 4 and at the end of time 8. We can use :func:`lifelines.utils.add_covariate_to_timeline` to fold the covariate dataset into the original dataset.
+
+
+.. code:: python
+
+      from lifelines.utils import add_covariate_to_timeline
+
+      cv = pd.DataFrame([
+        {'id': 1, 'time': 0, 'var2': 1.4},
+        {'id': 1, 'time': 4, 'var2': 1.2},
+        {'id': 1, 'time': 8, 'var2': 1.5},
+        {'id': 2, 'time': 0, 'var2': 1.6},
+
+      ])
+
+      df = add_covariate_to_timeline(base_df, cv, duration_col="time", id_col="id", event_col="event")
+
+
+.. table::
+
+    +--+-----+----+----+----+-----+
+    |id|start|stop|var1|var2|event|
+    +==+=====+====+====+====+=====+
+    | 1|    0|   4| 0.1| 1.4|False|
+    +--+-----+----+----+----+-----+
+    | 1|    4|   8| 0.1| 1.2|False|
+    +--+-----+----+----+----+-----+
+    | 1|    8|  10| 0.1| 1.5|True |
+    +--+-----+----+----+----+-----+
+    | 2|    0|  12| 0.5| 1.6|False|
+    +--+-----+----+----+----+-----+
+
+From the above output, we can see that subject 1 changed state twice over the observation period, finally expiring at the end of time 10. Subject 2 was a censored case, and we lost track of them after time 12.
+
+You may have multiple covariates you wish to add, so the above could be streamlined like so:
+
+.. code:: python
+
+      from lifelines.utils import add_covariate_to_timeline
+
+      df = base_df.pipe(add_covariate_to_timeline, cv1, duration_col="time", id_col="id", event_col="event")\
+                  .pipe(add_covariate_to_timeline, cv2, duration_col="time", id_col="id", event_col="event")\
+                  .pipe(add_covariate_to_timeline, cv3, duration_col="time", id_col="id", event_col="event")
+
+
+If your dataset is of the second type, that is, event-based, your dataset may look something like the following, where values in the matrix denote times since the subject's birth, and ``None`` or  ``NaN`` represent the event not happening (subjects can be excluded if the event never occurred as well) :
+
+.. code-block:: python
+
+    event_df = pd.DataFrame([
+        {'id': 1, 'E1': 1.0},
+        {'id': 2, 'E1': None},
+        {'id': 3, 'E1': 3.0},
+    ])
+
+    print(event_df)
+
+    """
+        id    E1
+    0   1     1.0
+    1   2     NaN
+    2   3     3.0
+    """
+    ...
+
+Initially, this can't be added to our baseline DataFrame. However, using :func:`lifelines.utils.covariates_from_event_matrix` we can convert a DataFrame like this into one that can be easily added.
+
+
+.. code-block:: python
+
+    from lifelines.utils import covariates_from_event_matrix
+
+    cv = covariates_from_event_matrix(event_df, id_col="id")
+    print(cv)
+
+    """
+       id  duration  E1
+    0   1       1.0   1
+    1   2       inf   1
+    2   3       3.0   1
+    """
+
+    base_df = pd.DataFrame([
+        {'id': 1, 'duration': 10, 'event': True, 'var1': 0.1},
+        {'id': 2, 'duration': 12, 'event': True, 'var1': 0.5}
+    ])
+    base_df = to_long_format(base_df, duration_col="duration")
+
+
+    base_df = add_covariate_to_timeline(base_df, cv, duration_col="duration", id_col="id", event_col="event")
+    """
+       start   E1  var1  stop  id  event
+    0    0.0  NaN   0.1   1.0   1  False
+    1    1.0  1.0   0.1  10.0   1   True
+    2    0.0  NaN   0.5  12.0   2   True
+    """
+
+For an example of pulling datasets like this from a SQL-store, and other helper functions, see :ref:`Example SQL queries and transformations to get time varying data`.
+
+Cumulative sums
+#############################################
+
+One additional flag on :func:`~lifelines.utils.add_covariate_to_timeline` that is of interest is the ``cumulative_sum`` flag. By default it is False, but turning it to True will perform a cumulative sum on the covariate before joining. This is useful if the covariates describe an incremental change, instead of a state update. For example, we may have measurements of drugs administered to a patient, and we want the covariate to reflect how much we have administered since the start. Event columns do make sense to cumulative sum as well. In contrast, a covariate to measure the temperature of the patient is a state update, and should not be summed.  See :ref:`Example cumulative sums over time-varying covariates` to see an example of this.
+
+Delaying time-varying covariates
+#############################################
+
+:func:`~lifelines.utils.add_covariate_to_timeline` also has an option for delaying, or shifting, a covariate so it changes later than originally observed. One may ask, why should one delay a time-varying covariate? Here's an example. Consider investigating the impact of smoking on mortality and available to us are time-varying observations of how many cigarettes are consumed each month. Unbeknownst to us, when a subject reaches critical illness levels, they are admitted to the hospital and their cigarette consumption drops to zero. Some expire while in hospital. If we used this dataset naively, we would see that *not* smoking leads to sudden death, and conversely, smoking helps your health! This is a case of reverse causation: the upcoming death event actually influences the covariates.
+
+To handle this, you can delay the observations by time periods. This has the possible of effect of dropping rows outside the observation window.
+
+.. code-block:: python
+
+    from lifelines.utils import add_covariate_to_timeline
+
+    cv = pd.DataFrame([
+        {'id': 1, 'time': 0, 'var2': 1.4},
+        {'id': 1, 'time': 4, 'var2': 1.2},
+        {'id': 1, 'time': 8, 'var2': 1.5},
+        {'id': 2, 'time': 0, 'var2': 1.6},
+    ])
+
+    base_df = pd.DataFrame([
+        {'id': 1, 'duration': 10, 'event': True, 'var1': 0.1},
+        {'id': 2, 'duration': 12, 'event': True, 'var1': 0.5}
+    ])
+    base_df = to_long_format(base_df, duration_col="duration")
+
+    base_df = add_covariate_to_timeline(base_df, cv, duration_col="time", id_col="id", event_col="event", delay=5)\
+                .fillna(0)
+
+    print(base_df)
+    """
+       start  var1  var2  stop  id  event
+    0      0   0.1   NaN   5.0   1  False
+    1      5   0.1   1.4   9.0   1  False
+    2      9   0.1   1.2  10.0   1   True
+    3      0   0.5   NaN   5.0   2  False
+    4      5   0.5   1.6  12.0   2   True
+    """
+
+
+Fitting the model
+################################################
+
+Once your dataset is in the correct orientation, we can use :class:`~lifelines.fitters.cox_time_varying_fitter.CoxTimeVaryingFitter` to fit the model to your data. The method is similar to :class:`~lifelines.fitters.coxph_fitter.CoxPHFitter`, except we need to tell the :meth:`~lifelines.fitters.cox_time_varying_fitter.CoxTimeVaryingFitter.fit` about the additional time columns.
+
+Fitting the Cox model to the data involves an iterative gradient descent. *lifelines* takes extra effort to help with convergence, so please be attentive to any warnings that appear. Fixing any warnings will generally help convergence. For further help, see :ref:`Problems with convergence in the Cox Proportional Hazard Model`.
+
+
+.. code:: python
+
+    from lifelines import CoxTimeVaryingFitter
+
+    ctv = CoxTimeVaryingFitter(penalizer=0.1)
+    ctv.fit(base_df, id_col="id", event_col="event", start_col="start", stop_col="stop", show_progress=True)
+    ctv.print_summary()
+    ctv.plot()
+
+
+Short note on prediction
+################################################
+
+Unlike the other regression models, prediction in a time-varying setting is not trivial. To predict, we would need to know the covariates values beyond the observed times, but if we knew that, we would also know if the subject was still alive or not! However, it is still possible to compute the hazard values of subjects at known observations, the baseline cumulative hazard rate, and baseline survival function. So while :class:`~lifelines.fitters.cox_time_varying_fitter.CoxTimeVaryingFitter` exposes prediction methods, there are logical limitations to what these predictions mean.

lifelines/source/docs/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

lifelines/source/docs/_static/custom.css

@@ -0,0 +1,3 @@
+.wy-nav-content {
+    max-width: 900px !important;
+}

lifelines/source/docs/_templates/layout.html

@@ -0,0 +1,6 @@
+{% extends "!layout.html" %}
+
+{%- block extrahead %}
+  <meta name="google-site-verification" content="9qrYvv6zs27wDrtk-LuEXmo-pKnAz2_w5g_hnHB9Ly8" />
+
+{% endblock %}

lifelines/source/docs/conf.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# lifelines documentation build configuration file, created by
+# sphinx-quickstart on Sun Feb  2 17:10:21 2014.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+from datetime import date
+import sys
+import os
+import lifelines
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath("."))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.coverage",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.napoleon",
+    "nbsphinx",
+    "sphinxcontrib.jquery",
+]
+
+exclude_patterns = ["_build", "jupyter_notebooks/.ipynb_checkpoints/*.ipynb"]
+
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix of source filenames.
+source_suffix = ".rst"
+
+# The encoding of source files.
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = "index"
+
+# General information about the project.
+project = "lifelines"
+copyright = "2014-{},  Cam Davidson-Pilon".format(date.today().year)
+
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+
+# The short X.Y version.
+version = lifelines.__version__
+# The full version, including alpha/beta/rc tags.
+release = version
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+# language = None
+
+autoclass_content = "both"  # include both class docstring and __init__
+autodoc_default_flags = [
+    # Make sure that any autodoc declarations show the right members
+    "members",
+    "inherited-members",
+    "show-inheritance",
+]
+autosummary_generate = True  # Make _autosummary files and include them
+
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+# today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ["_build"]
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "default"
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+# html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+# html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+# html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+# html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+# html_domain_indices = True
+
+# If false, no index is generated.
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "lifelinesdoc"
+
+# treat ``x, y : type`` as vars x and y instead of default ``y(x,) : type``
+napoleon_use_param = False
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [("index", "lifelines.tex", "lifelines Documentation", "Cam Davidson-Pilon", "manual")]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+# latex_appendices = []
+
+# If false, no module index is generated.
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [("index", "lifelines", "lifelines Documentation", ["Cam Davidson-Pilon"], 1)]
+
+# If true, show URL addresses after external links.
+# man_show_urls = False
+
+
+# nbsphinx
+nbsphinx_prolog = r"""
+.. image:: http://i.imgur.com/EOowdSD.png
+
+-------------------------------------
+
+
+"""
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    ("index", "lifelines", "lifelines Documentation", "Cam Davidson-Pilon", "lifelines", "Survival analysis in Python.")
+]
+
+# Documents to append as an appendix to all manuals.
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+# texinfo_no_detailmenu = False
+
+# use RTFD theme locally
+# on_rtd is whether we are on readthedocs.org, this line of code grabbed from docs.readthedocs.org
+import sphinx_rtd_theme
+
+html_theme = "sphinx_rtd_theme"
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path(), "."]
+
+
+def setup(app):
+    app.add_css_file("custom.css")

lifelines/source/docs/conftest.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from os import chdir, getcwd
+from shutil import rmtree
+from tempfile import mkdtemp
+import pytest
+from sybil import Sybil
+from sybil.parsers.codeblock import CodeBlockParser
+from sybil.parsers.doctest import DocTestParser
+
+
+@pytest.fixture(scope="module")
+def tempdir():
+    # there are better ways to do temp directories, but it's a simple example:
+    path = mkdtemp()
+    cwd = getcwd()
+    try:
+        chdir(path)
+        yield path
+    finally:
+        chdir(cwd)
+        rmtree(path)
+
+
+# uncomment to use locally.
+# run `py.test` in the docs folder
+"""
+pytest_collect_file = Sybil(
+    parsers=[DocTestParser(), CodeBlockParser(future_imports=["print_function"])], pattern="*.rst", fixtures=["tempdir"]
+).pytest()
+"""

lifelines/source/docs/docs_requirements.txt

@@ -0,0 +1 @@
+-r ../reqs/docs-requirements.txt

lifelines/source/docs/fitters/regression/AalenAdditiveFitter.rst

@@ -0,0 +1,7 @@
+
+AalenAdditiveFitter
+------------------------------------------------
+
+.. automodule:: lifelines.fitters.aalen_additive_fitter
+    :members:
+    :undoc-members:

lifelines/source/docs/fitters/regression/CRCSplineFitter.rst

@@ -0,0 +1,6 @@
+CRCSplineFitter
+------------------------------------------
+
+.. automodule:: lifelines.fitters.crc_spline_fitter
+    :members:
+    :undoc-members:

lifelines/source/docs/fitters/regression/CoxPHFitter.rst

@@ -0,0 +1,71 @@
+CoxPHFitter
+--------------------------------------
+
+.. autoclass:: lifelines.fitters.coxph_fitter.CoxPHFitter
+    :members:
+    :undoc-members:
+
+    .. method:: plot_covariate_groups()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.plot_covariate_groups`
+
+
+    .. method:: plot_partial_effects_on_outcome()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.plot_partial_effects_on_outcome`
+
+
+    .. method:: plot()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.plot`
+
+
+    .. method:: predict_median()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_median`
+
+
+    .. method:: predict_expectation()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_expectation`
+
+
+    .. method:: predict_percentile()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_percentile`
+
+
+    .. method:: predict_survival_function()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_survival_function`
+
+
+    .. method:: predict_partial_hazard()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_partial_hazard`
+
+
+    .. method:: predict_log_partial_hazard()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_log_partial_hazard`
+
+
+    .. method:: predict_cumulative_hazard()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.predict_cumulative_hazard`
+
+    .. method:: score()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.score`
+
+
+    .. method:: log_likelihood_ratio_test()
+
+        see :meth:`~lifelines.fitters.coxph_fitter.SemiParametricPHFitter.log_likelihood_ratio_test`
+
+
+.. autoclass:: lifelines.fitters.coxph_fitter.SemiParametricPHFitter
+    :members:
+
+.. autoclass:: lifelines.fitters.coxph_fitter.ParametricSplinePHFitter
+    :members:

lifelines/source/docs/fitters/regression/CoxTimeVaryingFitter.rst

@@ -0,0 +1,6 @@
+CoxTimeVaryingFitter
+---------------------------------------------------
+
+.. automodule:: lifelines.fitters.cox_time_varying_fitter
+    :members:
+    :undoc-members:

lifelines/source/docs/fitters/regression/GeneralizedGammaRegressionFitter.rst

@@ -0,0 +1,6 @@
+GeneralizedGammaRegressionFitter
+------------------------------------------
+
+.. automodule:: lifelines.fitters.generalized_gamma_regression_fitter
+    :members:
+    :undoc-members:

lifelines/source/docs/fitters/regression/LogLogisticAFTFitter.rst

@@ -0,0 +1,7 @@
+
+LogLogisticAFTFitter
+-----------------------------------------------------
+
+.. automodule:: lifelines.fitters.log_logistic_aft_fitter
+    :members:
+    :undoc-members: