coxdev 0.1.2__tar.gz → 0.1.4__tar.gz

coxdev-0.1.4/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: coxdev
+Version: 0.1.4
+Summary: Library for computing Cox deviance
+Author-email: Jonathan Taylor <jonathan.taylor@stanford.edu>, Trevor Hastie <hastie@stanford.edu>, Balasubramanian Narasimhan <naras@stanford.edu>
+Maintainer-email: Jonathan Taylor <jonathan.taylor@stanford.edu>
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.7.1
+Requires-Dist: joblib
+Requires-Dist: scipy
+
+# coxdev
+
+A high-performance Python library for computing Cox proportional hazards model deviance, gradients, and Hessian information matrices. Built with C++ and Eigen for optimal performance, this library provides efficient survival analysis computations with support for different tie-breaking methods.
+
+## Features
+
+- **High Performance**: C++ implementation with Eigen linear algebra library
+- **Comprehensive Support**: Handles both Efron and Breslow tie-breaking methods
+- **Left-Truncated Data**: Support for left-truncated survival data
+- **Efficient Computations**: Optimized algorithms for deviance, gradient, and Hessian calculations
+- **Memory Efficient**: Uses linear operators for large-scale computations
+- **Cross-Platform**: Works on Linux, macOS, and Windows
+
+## Installation
+
+### Prerequisites
+
+This package requires the Eigen C++ library headers. The Eigen library is included as a git submodule.
+
+1. **Initialize Eigen submodule**: The Eigen library is included as a git submodule. Make sure it's initialized:
+   ```bash
+   git submodule update --init --recursive
+   ```
+
+2. **Check Eigen availability**: Run the check script to verify Eigen headers are available:
+   ```bash
+   python check_eigen.py
+   ```
+
+### Standard Installation
+
+```bash
+pip install .
+```
+
+### With Custom Eigen Path
+
+If you have Eigen installed elsewhere, you can specify its location:
+```bash
+env EIGEN_LIBRARY_PATH=/path/to/eigen pip install .
+```
+
+### Development Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from coxdev import CoxDeviance
+
+# Generate sample survival data
+n_samples = 1000
+event_times = np.random.exponential(1.0, n_samples)
+status = np.random.binomial(1, 0.7, n_samples)  # 70% events, 30% censored
+linear_predictor = np.random.normal(0, 1, n_samples)
+
+# Create CoxDeviance object
+coxdev = CoxDeviance(event=event_times, status=status, tie_breaking='efron')
+
+# Compute deviance and related quantities
+result = coxdev(linear_predictor)
+
+print(f"Deviance: {result.deviance:.4f}")
+print(f"Saturated log-likelihood: {result.loglik_sat:.4f}")
+print(f"Gradient norm: {np.linalg.norm(result.gradient):.4f}")
+```
+
+## Advanced Usage
+
+### Left-Truncated Data
+
+```python
+# With start times (left-truncated data)
+start_times = np.random.exponential(0.5, n_samples)
+coxdev = CoxDeviance(
+    event=event_times, 
+    status=status, 
+    start=start_times,
+    tie_breaking='efron'
+)
+```
+
+### Computing Information Matrix
+
+```python
+# Get information matrix as a linear operator
+info_matrix = coxdev.information(linear_predictor)
+
+# Matrix-vector multiplication
+v = np.random.normal(0, 1, n_samples)
+result_vector = info_matrix @ v
+
+# For small problems, you can compute the full matrix
+X = np.random.normal(0, 1, (n_samples, 10))
+beta = np.random.normal(0, 1, 10)
+eta = X @ beta
+
+# Information matrix for coefficients: X^T @ I @ X
+I = info_matrix @ X
+information_matrix = X.T @ I
+```
+
+### Different Tie-Breaking Methods
+
+```python
+# Efron's method (default)
+coxdev_efron = CoxDeviance(event=event_times, status=status, tie_breaking='efron')
+
+# Breslow's method
+coxdev_breslow = CoxDeviance(event=event_times, status=status, tie_breaking='breslow')
+```
+
+## API Reference
+
+### CoxDeviance
+
+The main class for computing Cox model quantities.
+
+#### Parameters
+
+- **event**: Event times (failure times) for each observation
+- **status**: Event indicators (1 for event occurred, 0 for censored)
+- **start**: Start times for left-truncated data (optional)
+- **tie_breaking**: Method for handling tied event times ('efron' or 'breslow')
+
+#### Methods
+
+- **`__call__(linear_predictor, sample_weight=None)`**: Compute deviance and related quantities
+- **`information(linear_predictor, sample_weight=None)`**: Get information matrix as linear operator
+
+### CoxDevianceResult
+
+Result object containing computation results.
+
+#### Attributes
+
+- **linear_predictor**: The linear predictor values used
+- **sample_weight**: Sample weights used
+- **loglik_sat**: Saturated log-likelihood value
+- **deviance**: Computed deviance value
+- **gradient**: Gradient of deviance with respect to linear predictor
+- **diag_hessian**: Diagonal of Hessian matrix
+
+## Performance
+
+The library is optimized for performance:
+
+- **C++ Implementation**: Core computations in C++ with Eigen
+- **Memory Efficient**: Reuses buffers and uses linear operators
+- **Vectorized Operations**: Leverages Eigen's optimized linear algebra
+- **Minimal Python Overhead**: Heavy computations done in C++
+
+## Building from Source
+
+### Prerequisites
+
+- Python 3.9+
+- C++ compiler with C++17 support
+- Eigen library headers
+- pybind11
+
+### Build Steps
+
+1. Clone the repository with submodules:
+   ```bash
+   git clone --recursive https://github.com/jonathan-taylor/coxdev.git
+   cd coxdev
+   ```
+
+2. Install build dependencies:
+   ```bash
+   pip install build wheel setuptools pybind11 numpy
+   ```
+
+3. Build the package:
+   ```bash
+   python -m build
+   ```
+
+### Building Wheels
+
+For wheel building:
+```bash
+# Standard wheel build
+python -m build
+
+# With custom Eigen path
+env EIGEN_LIBRARY_PATH=/path/to/eigen python -m build
+```
+
+## Testing
+
+Run the test suite:
+```bash
+python -m pytest tests/
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Ensure all tests pass
+6. Submit a pull request
+
+## License
+
+This project is licensed under the BSD-3-Clause License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this library in your research, please cite:
+
+```bibtex
+@software{coxdev2024,
+  title={coxdev: High-performance Cox proportional hazards deviance computation},
+  author={Taylor, Jonathan and Hastie, Trevor and Narasimhan, Balasubramanian},
+  year={2024},
+  url={https://github.com/jonathan-taylor/coxdev}
+}
+```
+
+## Acknowledgments
+
+- Built with [Eigen](http://eigen.tuxfamily.org/) for efficient linear algebra
+- Uses [pybind11](https://pybind11.readthedocs.io/) for Python bindings
+- Inspired by the R `glmnet` package for survival analysis

coxdev-0.1.4/README.md

@@ -0,0 +1,232 @@
+# coxdev
+
+A high-performance Python library for computing Cox proportional hazards model deviance, gradients, and Hessian information matrices. Built with C++ and Eigen for optimal performance, this library provides efficient survival analysis computations with support for different tie-breaking methods.
+
+## Features
+
+- **High Performance**: C++ implementation with Eigen linear algebra library
+- **Comprehensive Support**: Handles both Efron and Breslow tie-breaking methods
+- **Left-Truncated Data**: Support for left-truncated survival data
+- **Efficient Computations**: Optimized algorithms for deviance, gradient, and Hessian calculations
+- **Memory Efficient**: Uses linear operators for large-scale computations
+- **Cross-Platform**: Works on Linux, macOS, and Windows
+
+## Installation
+
+### Prerequisites
+
+This package requires the Eigen C++ library headers. The Eigen library is included as a git submodule.
+
+1. **Initialize Eigen submodule**: The Eigen library is included as a git submodule. Make sure it's initialized:
+   ```bash
+   git submodule update --init --recursive
+   ```
+
+2. **Check Eigen availability**: Run the check script to verify Eigen headers are available:
+   ```bash
+   python check_eigen.py
+   ```
+
+### Standard Installation
+
+```bash
+pip install .
+```
+
+### With Custom Eigen Path
+
+If you have Eigen installed elsewhere, you can specify its location:
+```bash
+env EIGEN_LIBRARY_PATH=/path/to/eigen pip install .
+```
+
+### Development Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from coxdev import CoxDeviance
+
+# Generate sample survival data
+n_samples = 1000
+event_times = np.random.exponential(1.0, n_samples)
+status = np.random.binomial(1, 0.7, n_samples)  # 70% events, 30% censored
+linear_predictor = np.random.normal(0, 1, n_samples)
+
+# Create CoxDeviance object
+coxdev = CoxDeviance(event=event_times, status=status, tie_breaking='efron')
+
+# Compute deviance and related quantities
+result = coxdev(linear_predictor)
+
+print(f"Deviance: {result.deviance:.4f}")
+print(f"Saturated log-likelihood: {result.loglik_sat:.4f}")
+print(f"Gradient norm: {np.linalg.norm(result.gradient):.4f}")
+```
+
+## Advanced Usage
+
+### Left-Truncated Data
+
+```python
+# With start times (left-truncated data)
+start_times = np.random.exponential(0.5, n_samples)
+coxdev = CoxDeviance(
+    event=event_times, 
+    status=status, 
+    start=start_times,
+    tie_breaking='efron'
+)
+```
+
+### Computing Information Matrix
+
+```python
+# Get information matrix as a linear operator
+info_matrix = coxdev.information(linear_predictor)
+
+# Matrix-vector multiplication
+v = np.random.normal(0, 1, n_samples)
+result_vector = info_matrix @ v
+
+# For small problems, you can compute the full matrix
+X = np.random.normal(0, 1, (n_samples, 10))
+beta = np.random.normal(0, 1, 10)
+eta = X @ beta
+
+# Information matrix for coefficients: X^T @ I @ X
+I = info_matrix @ X
+information_matrix = X.T @ I
+```
+
+### Different Tie-Breaking Methods
+
+```python
+# Efron's method (default)
+coxdev_efron = CoxDeviance(event=event_times, status=status, tie_breaking='efron')
+
+# Breslow's method
+coxdev_breslow = CoxDeviance(event=event_times, status=status, tie_breaking='breslow')
+```
+
+## API Reference
+
+### CoxDeviance
+
+The main class for computing Cox model quantities.
+
+#### Parameters
+
+- **event**: Event times (failure times) for each observation
+- **status**: Event indicators (1 for event occurred, 0 for censored)
+- **start**: Start times for left-truncated data (optional)
+- **tie_breaking**: Method for handling tied event times ('efron' or 'breslow')
+
+#### Methods
+
+- **`__call__(linear_predictor, sample_weight=None)`**: Compute deviance and related quantities
+- **`information(linear_predictor, sample_weight=None)`**: Get information matrix as linear operator
+
+### CoxDevianceResult
+
+Result object containing computation results.
+
+#### Attributes
+
+- **linear_predictor**: The linear predictor values used
+- **sample_weight**: Sample weights used
+- **loglik_sat**: Saturated log-likelihood value
+- **deviance**: Computed deviance value
+- **gradient**: Gradient of deviance with respect to linear predictor
+- **diag_hessian**: Diagonal of Hessian matrix
+
+## Performance
+
+The library is optimized for performance:
+
+- **C++ Implementation**: Core computations in C++ with Eigen
+- **Memory Efficient**: Reuses buffers and uses linear operators
+- **Vectorized Operations**: Leverages Eigen's optimized linear algebra
+- **Minimal Python Overhead**: Heavy computations done in C++
+
+## Building from Source
+
+### Prerequisites
+
+- Python 3.9+
+- C++ compiler with C++17 support
+- Eigen library headers
+- pybind11
+
+### Build Steps
+
+1. Clone the repository with submodules:
+   ```bash
+   git clone --recursive https://github.com/jonathan-taylor/coxdev.git
+   cd coxdev
+   ```
+
+2. Install build dependencies:
+   ```bash
+   pip install build wheel setuptools pybind11 numpy
+   ```
+
+3. Build the package:
+   ```bash
+   python -m build
+   ```
+
+### Building Wheels
+
+For wheel building:
+```bash
+# Standard wheel build
+python -m build
+
+# With custom Eigen path
+env EIGEN_LIBRARY_PATH=/path/to/eigen python -m build
+```
+
+## Testing
+
+Run the test suite:
+```bash
+python -m pytest tests/
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Ensure all tests pass
+6. Submit a pull request
+
+## License
+
+This project is licensed under the BSD-3-Clause License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this library in your research, please cite:
+
+```bibtex
+@software{coxdev2024,
+  title={coxdev: High-performance Cox proportional hazards deviance computation},
+  author={Taylor, Jonathan and Hastie, Trevor and Narasimhan, Balasubramanian},
+  year={2024},
+  url={https://github.com/jonathan-taylor/coxdev}
+}
+```
+
+## Acknowledgments
+
+- Built with [Eigen](http://eigen.tuxfamily.org/) for efficient linear algebra
+- Uses [pybind11](https://pybind11.readthedocs.io/) for Python bindings
+- Inspired by the R `glmnet` package for survival analysis

coxdev-0.1.4/coxdev/__init__.py

@@ -0,0 +1,21 @@
+"""
+coxdev: Efficient Cox Proportional Hazards Model Deviance and Information
+
+This package provides efficient computation of Cox model deviance, gradients, and information matrices
+for survival analysis, including support for stratified models and different tie-breaking methods.
+
+Main Classes
+------------
+CoxDeviance
+    Standard Cox model deviance and information computation.
+StratifiedCoxDeviance
+    Stratified Cox model deviance and information computation.
+
+See Also
+--------
+coxdev.base : Core Cox model implementation.
+coxdev.stratified : Stratified Cox model implementation.
+"""
+
+from .base import CoxDeviance
+from .stratified import StratifiedCoxDeviance

{coxdev-0.1.2 → coxdev-0.1.4}/coxdev/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-06-25T21:52:54-0700",
+ "date": "2025-07-11T13:26:28-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "7364f3be8e732fbee4fa486c058fe55e70e546c2",
- "version": "0.1.2"
+ "full-revisionid": "0ccbd28a93a84afbc73f6f32f752b5f40c349d6d",
+ "version": "0.1.4"
 }
 '''  # END VERSION_JSON
 

coxdev-0.1.2/coxdev/__init__.py → coxdev-0.1.4/coxdev/base.py

@@ -16,12 +16,12 @@ from . import _version
 __version__ = _version.get_versions()['version']
 
 import numpy as np
-from joblib import hash
+from joblib import hash as _hash
 
-from coxc import (cox_dev as _cox_dev,
-                  hessian_matvec as _hessian_matvec,
-                  compute_sat_loglik as _compute_sat_loglik,
-                  c_preprocess)
+from .coxc import (cox_dev as _cox_dev,
+                   hessian_matvec as _hessian_matvec,
+                   compute_sat_loglik as _compute_sat_loglik,
+                   c_preprocess)
 
     
 @dataclass
@@ -84,6 +84,18 @@ class CoxDeviance(object):
         Whether start times are provided.
     _efron : bool
         Whether Efron's method is being used for tie-breaking.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from coxdev import CoxDeviance
+    >>> event = np.array([3, 6, 8, 4, 6, 4, 3, 2, 2, 5, 3, 4])
+    >>> status = np.array([1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1])
+    >>> cox = CoxDeviance(event=event, status=status)
+    >>> eta = np.linspace(-1, 1, len(event))
+    >>> result = cox(eta)
+    >>> print(round(result.deviance, 4))
+    20.7998
     """
     
     event: InitVar[np.ndarray]
@@ -107,8 +119,13 @@ class CoxDeviance(object):
         start : np.ndarray, optional
             Start times for left-truncated data.
         """
-        event = np.asarray(event)
-        status = np.asarray(status).astype(np.int32)
+        event = np.asarray(event).astype(float)
+
+        status_arr = np.asarray(status)
+        if not set(np.unique(status_arr)).issubset(set([0,1])):
+            raise ValueError('status must be binary')
+        status = status_arr.astype(np.int32)
+        
         nevent = event.shape[0]
 
         if start is None:
@@ -147,14 +164,10 @@ class CoxDeviance(object):
         
         self._T_1_term = np.zeros(n)
         self._T_2_term = np.zeros(n)
-        # self._event_reorder_buffers = np.zeros((3, n))
         self._event_reorder_buffers = [np.zeros(n) for i in range(3)]
-        # self._forward_cumsum_buffers = np.zeros((5, n+1))
         self._forward_cumsum_buffers = [np.zeros(n+1) for i in range(5)]
         self._forward_scratch_buffer = np.zeros(n)
-        # self._reverse_cumsum_buffers = np.zeros((4, n+1))
         self._reverse_cumsum_buffers = [np.zeros(n+1) for i in range(4)]
-        # self._risk_sum_buffers = np.zeros((2, n))
         self._risk_sum_buffers = [np.zeros(n) for i in range(2)]
         self._hess_matvec_buffer = np.zeros(n)
         self._grad_buffer = np.zeros(n)
@@ -188,7 +201,7 @@ class CoxDeviance(object):
 
         linear_predictor = np.asarray(linear_predictor)
             
-        cur_hash = hash([linear_predictor, sample_weight])
+        cur_hash = _hash([linear_predictor, sample_weight])
         if not hasattr(self, "_result") or self._result.__hash_args__ != cur_hash:
 
             loglik_sat = _compute_sat_loglik(self._first,
@@ -201,31 +214,11 @@ class CoxDeviance(object):
             eta = np.asarray(linear_predictor)
             sample_weight = np.asarray(sample_weight)
             eta = eta - eta.mean()
-            self._exp_w_buffer[:] = sample_weight * np.exp(eta)
-
-            # print(f'eta type {eta.dtype}')
-            # print(f'sample_weight type {sample_weight.dtype}')
-            # print(f'self._exp_w_buffer {self._exp_w_buffer.dtype}')
-            # print(f'self._event_order {self._event_order.dtype}')
-            # print(f'self._start_order {self._start_order.dtype}')
-            # print(f'self._status {self._status.dtype}')
-            # print(f'self._first {self._first.dtype}')
-            # print(f'self._last {self._last.dtype}')
-            # print(f'self._scaling {self._scaling.dtype}')
-            # print(f'self._event_map {self._event_map.dtype}')
-            # print(f'self._start_map {self._start_map.dtype}')
-            # print(f'self._T_1_term {self._T_1_term.dtype}')
-            # print(f'self._T_2_term {self._T_2_term.dtype}')
-            # print(f'self._grad_buffer {self._grad_buffer.dtype}')
-            # print(f'self._diag_hessian_buffer {self._diag_hessian_buffer.dtype}')
-            # print(f'self._diag_part_buffer {self._diag_part_buffer.dtype}')
-            # print(f'self._w_avg_buffer {self._w_avg_buffer.dtype}')
-            # #print(f'self._event_reorder_buffers {self._event_reorder_buffers.dtype}')
-            # #print(f'self._risk_sum_buffers {self._risk_sum_buffers.dtype}')
-            # #print(f'self._forward_cumsum_buffers {self._forward_cumsum_buffers.dtype}')
-            # print(f'self._forward_scratch_buffer {self._forward_scratch_buffer.dtype}')
-            # #print(f'self._reverse_cumsum_buffers {self._reverse_cumsum_buffers.dtype}')
-            
+            self._exp_w_buffer[:] = sample_weight * np.exp(np.clip(eta, -np.inf, 30))
+
+
+
+
             deviance = _cox_dev(eta,
                                 sample_weight,
                                 self._exp_w_buffer,

{coxdev-0.1.2 → coxdev-0.1.4}/coxdev/info.py

@@ -14,15 +14,15 @@ description  = 'CoxDev (Python)'
 
 NAME                = 'coxdev'
 MAINTAINER          = "Naras Balasubrimanian, Trevor Hastie, Jonathan Taylor"
-MAINTAINER_EMAIL    = ""
+MAINTAINER_EMAIL    = "jonathan.taylor@stanford.edu"
 DESCRIPTION         = description
 LONG_DESCRIPTION    = description
 URL                 = "https://github.org/jonathan-taylor/coxdev"
 DOWNLOAD_URL        = ""
-LICENSE             = "BSD license"
+LICENSE             = "BSD-3-Clause"
 CLASSIFIERS         = CLASSIFIERS
 AUTHOR              = "Naras Balasubrimanian, Trevor Hastie, Jonathan Taylor"
-AUTHOR_EMAIL        = ""
+AUTHOR_EMAIL        = "jonathan.taylor@stanford.edu"
 PLATFORMS           = "OS Independent"
 STATUS              = 'alpha'