scikit-survival 0.24.1__cp313-cp313-win_amd64.whl → 0.26.0__cp313-cp313-win_amd64.whl

sksurv/svm/minlip.py

@@ -19,11 +19,23 @@ __all__ = ["MinlipSurvivalAnalysis", "HingeLossSurvivalSVM"]
 
 
 class QPSolver(metaclass=ABCMeta):
-    """
-    Solves a quadratic program::
+    r"""Abstract base class for quadratic program solvers.
+
+    This class defines the interface for solvers that minimize a quadratic
+    objective function subject to linear inequality constraints,
+    formulated as:
+
+    .. math::
+
+        \min_{x} \quad (1/2)x^T P x + q^T x \\
+        \text{subject to} \quad G x \preceq h
 
-        minimize    (1/2)*x'*P*x + q'*x
-        subject to  G*x <= h
+    Parameters
+    ----------
+    max_iter : int or None
+        Maximum number of iterations to perform.
+    verbose : bool
+        Enable verbose output of the solver.
     """
 
     @abstractmethod
@@ -33,7 +45,26 @@ class QPSolver(metaclass=ABCMeta):
 
     @abstractmethod
     def solve(self, P, q, G, h):
-        """Returns solution to QP."""
+        """Find solution to QP.
+
+        Parameters
+        ----------
+        P : array-like, shape=(n_variables, n_variables)
+            Quadratic part of the objective function.
+        q : array-like, shape=(n_variables,)
+            Linear part of the objective function.
+        G : array-like, shape=(n_constraints, n_variables)
+            Matrix for inequality constraints.
+        h : array-like, shape=(n_constraints,)
+            Vector for inequality constraints.
+
+        Returns
+        -------
+        x : ndarray, shape=(n_variables,)
+            The optimal solution.
+        n_iter : int
+            Number of iterations performed by the solver.
+        """
 
 
 class OsqpSolver(QPSolver):
@@ -50,42 +81,58 @@ class OsqpSolver(QPSolver):
 
         solver_opts = self._get_options()
         m = osqp.OSQP()
-        m.setup(P=sparse.csc_matrix(P), q=q, A=G, u=h, **solver_opts)  # noqa: E741
-        results = m.solve()
+        m.setup(P=sparse.csc_matrix(P), q=q, A=G, l=None, u=h, **solver_opts)  # noqa: E741
+        results = m.solve(raise_error=False)
+
+        solved_codes = (
+            osqp.SolverStatus.OSQP_SOLVED,
+            osqp.SolverStatus.OSQP_SOLVED_INACCURATE,
+        )
 
-        if results.info.status_val == -2:  # max iter reached
+        if results.info.status_val == osqp.SolverStatus.OSQP_MAX_ITER_REACHED:  # max iter reached
             warnings.warn(
                 (f"OSQP solver did not converge: {results.info.status}"),
                 category=ConvergenceWarning,
                 stacklevel=2,
             )
-        elif results.info.status_val not in (1, 2):  # pragma: no cover
-            # non of solved, solved inaccurate
+        elif results.info.status_val not in solved_codes:  # pragma: no cover
+            # none of SOLVED, SOLVED_INACCURATE
             raise RuntimeError(f"OSQP solver failed: {results.info.status}")
 
         n_iter = results.info.iter
         return results.x[np.newaxis], n_iter
 
     def _get_options(self):
+        """Returns a dictionary of OSQP solver options."""
         solver_opts = {
             "eps_abs": 1e-5,
             "eps_rel": 1e-5,
             "max_iter": self.max_iter or 4000,
-            "polish": True,
+            "polishing": True,
             "verbose": self.verbose,
         }
         return solver_opts
 
 
 class EcosSolver(QPSolver):
-    """Solves QP by expressing it as second-order cone program::
+    r"""Solves QP by expressing it as second-order cone program:
+
+    .. math::
 
-        minimize    c^T @ x
-        subject to  G @ x <=_K h
+        \min \quad c^T x \\
+        \text{subject to} \quad G x \preceq_K h
 
-    where the last inequality is generalized, i.e. ``h - G*x``
-    belongs to the cone ``K``. ECOS supports the positive orthant
-    ``R_+`` and second-order cones ``Q_n``.
+    where the last inequality is generalized, i.e. :math:`h - G x`
+    belongs to the cone :math:`K`.
+
+    Parameters
+    ----------
+    max_iter : int or None
+        Maximum number of iterations to perform.
+    verbose : bool
+        Enable verbose output of the solver.
+    cond : float or None, default: None
+        Condition number for eigenvalue decomposition.
     """
 
     EXIT_OPTIMAL = 0  # Optimal solution found
@@ -144,6 +191,18 @@ class EcosSolver(QPSolver):
         return x[np.newaxis], n_iter
 
     def _check_success(self, results):  # pylint: disable=no-self-use
+        """Checks if the ECOS solver converged successfully.
+
+        Parameters
+        ----------
+        results : dict
+            The results dictionary returned by ``ecos.solve``.
+
+        Raises
+        -------
+        RuntimeError
+            If the solver failed for an unknown reason or found primal/dual infeasibility.
+        """
         exit_flag = results["info"]["exitFlag"]
         if exit_flag in (EcosSolver.EXIT_OPTIMAL, EcosSolver.EXIT_OPTIMAL + EcosSolver.EXIT_INACC_OFFSET):
             return
@@ -160,6 +219,20 @@ class EcosSolver(QPSolver):
             raise RuntimeError(f"Unknown problem in ECOS solver, exit status: {exit_flag}")
 
     def _decompose(self, P):
+        """Performs eigenvalue decomposition of P.
+
+        Parameters
+        ----------
+        P : array-like, shape=(n_variables, n_variables)
+            Quadratic part of the objective function.
+
+        Returns
+        -------
+        decomposed : ndarray
+            Decomposed matrix.
+        largest_eigenvalue : float
+            The largest eigenvalue of P.
+        """
         # from scipy.linalg.pinvh
         s, u = linalg.eigh(P)
         largest_eigenvalue = np.max(np.abs(s))
@@ -182,33 +255,38 @@ class EcosSolver(QPSolver):
 
 
 class MinlipSurvivalAnalysis(BaseEstimator, SurvivalAnalysisMixin):
-    """Survival model related to survival SVM, using a minimal Lipschitz smoothness strategy
-    instead of a maximal margin strategy.
+    r"""Survival model based on a minimal Lipschitz smoothness strategy.
+
+    This model is related to :class:`sksurv.svm.FastKernelSurvivalSVM` but
+    minimizes a different objective function, focusing on Lipschitz
+    smoothness rather than maximal margin. The optimization problem is
+    formulated as:
 
     .. math::
 
-          \\min_{\\mathbf{w}}\\quad
-          \\frac{1}{2} \\lVert \\mathbf{w} \\rVert_2^2
-          + \\gamma \\sum_{i = 1}^n \\xi_i \\\\
-          \\text{subject to}\\quad
-          \\mathbf{w}^\\top \\mathbf{x}_i - \\mathbf{w}^\\top \\mathbf{x}_j \\geq y_i - y_j - \\xi_i,\\quad
-          \\forall (i, j) \\in \\mathcal{P}_\\text{1-NN}, \\\\
-          \\xi_i \\geq 0,\\quad \\forall i = 1,\\dots,n.
+            \min_{\mathbf{w}}\quad
+        \frac{1}{2} \lVert \mathbf{w} \rVert_2^2
+        + \gamma \sum_{i = 1}^n \xi_i \\
+        \text{subject to}\quad
+        \mathbf{w}^\top \mathbf{x}_i - \mathbf{w}^\top \mathbf{x}_j \geq y_i - y_j - \xi_i,\quad
+        \forall (i, j) \in \mathcal{P}_\text{1-NN}, \\
+        \xi_i \geq 0,\quad \forall i = 1,\dots,n.
 
-          \\mathcal{P}_\\text{1-NN} = \\{ (i, j) \\mid y_i > y_j \\land \\delta_j = 1
-          \\land \\nexists k : y_i > y_k > y_j \\land \\delta_k = 1 \\}_{i,j=1}^n.
+        \mathcal{P}_\text{1-NN} = \{ (i, j) \mid y_i > y_j \land \delta_j = 1
+        \land \nexists k : y_i > y_k > y_j \land \delta_k = 1 \}_{i,j=1}^n.
 
     See [1]_ for further description.
 
     Parameters
     ----------
-    alpha : float, positive, default: 1
+    alpha : float, optional, default: 1
         Weight of penalizing the hinge loss in the objective function.
+        Must be greater than 0.
 
     solver : {'ecos', 'osqp'}, optional, default: 'ecos'
         Which quadratic program solver to use.
 
-    kernel : str or callable, default: 'linear'.
+    kernel : str or callable, optional, default: 'linear'.
         Kernel mapping used internally. This parameter is directly passed to
         :func:`sklearn.metrics.pairwise.pairwise_kernels`.
         If `kernel` is a string, it must be one of the metrics
@@ -228,52 +306,52 @@ class MinlipSurvivalAnalysis(BaseEstimator, SurvivalAnalysisMixin):
         the kernel; see the documentation for :mod:`sklearn.metrics.pairwise`.
         Ignored by other kernels.
 
-    degree : int, default: 3
+    degree : int, optional, default: 3
         Degree of the polynomial kernel. Ignored by other kernels.
 
-    coef0 : float, optional
+    coef0 : float, optional, default: 1
         Zero coefficient for polynomial and sigmoid kernels.
         Ignored by other kernels.
 
-    kernel_params : mapping of string to any, optional
+    kernel_params : dict, optional, default: None
         Additional parameters (keyword arguments) for kernel function passed
         as callable object.
 
     pairs : {'all', 'nearest', 'next'}, optional, default: 'nearest'
         Which constraints to use in the optimization problem.
 
-        - all: Use all comparable pairs. Scales quadratic in number of samples
+        - all: Use all comparable pairs. Scales quadratically in number of samples
           (cf. :class:`sksurv.svm.HingeLossSurvivalSVM`).
         - nearest: Only considers comparable pairs :math:`(i, j)` where :math:`j` is the
           uncensored sample with highest survival time smaller than :math:`y_i`.
-          Scales linear in number of samples.
+          Scales linearly in number of samples.
         - next: Only compare against direct nearest neighbor according to observed time,
-          disregarding its censoring status. Scales linear in number of samples.
+          disregarding its censoring status. Scales linearly in number of samples.
 
-    verbose : bool, default: False
+    verbose : bool, optional, default: False
         Enable verbose output of solver.
 
-    timeit : False, int or None, default: None
-        If non-zero value is provided the time it takes for optimization is measured.
-        The given number of repetitions are performed. Results can be accessed from the
-        ``timings_`` attribute.
+    timeit : bool, int, or None, optional, default: False
+        If ``True`` or a non-zero integer, the time taken for optimization is measured.
+        If an integer is provided, the optimization is repeated that many times.
+        Results can be accessed from the ``timings_`` attribute.
 
     max_iter : int or None, optional, default: None
-        Maximum number of iterations to perform. By default
-        use solver's default value.
+        The maximum number of iterations taken for the solvers to converge.
+        If ``None``, use solver's default value.
 
     Attributes
     ----------
-    X_fit_ : ndarray
+    X_fit_ : ndarray, shape = (n_samples, `n_features_in_`)
         Training data.
 
-    coef_ : ndarray, shape = (n_samples,)
+    coef_ : ndarray, shape = (n_samples,), dtype = float
         Coefficients of the features in the decision function.
 
     n_features_in_ : int
         Number of features seen during ``fit``.
 
-    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+    feature_names_in_ : ndarray, shape = (`n_features_in_`,)
         Names of features seen during ``fit``. Defined only when `X`
         has feature names that are all strings.
 
@@ -405,9 +483,9 @@ class MinlipSurvivalAnalysis(BaseEstimator, SurvivalAnalysisMixin):
             Data matrix.
 
         y : structured array, shape = (n_samples,)
-            A structured array containing the binary event indicator
-            as first field, and time of event or time of censoring as
-            second field.
+            A structured array with two fields. The first field is a boolean
+            where ``True`` indicates an event and ``False`` indicates right-censoring.
+            The second field is a float with the time of event or time of censoring.
 
         Returns
         -------
@@ -423,8 +501,10 @@ class MinlipSurvivalAnalysis(BaseEstimator, SurvivalAnalysisMixin):
     def predict(self, X):
         """Predict risk score of experiencing an event.
 
-        Higher scores indicate shorter survival (high risk),
-        lower scores longer survival (low risk).
+        Higher values indicate an increased risk of experiencing an event,
+        lower values a decreased risk of experiencing an event. The scores
+        have no unit and are only meaningful to rank samples by their risk
+        of experiencing an event.
 
         Parameters
         ----------
@@ -443,37 +523,39 @@ class MinlipSurvivalAnalysis(BaseEstimator, SurvivalAnalysisMixin):
 
 
 class HingeLossSurvivalSVM(MinlipSurvivalAnalysis):
-    """Naive implementation of kernel survival support vector machine.
+    r"""Naive implementation of kernel survival support vector machine.
 
-    A new set of samples is created by building the difference between any two feature
-    vectors in the original data, thus this version requires :math:`O(\\text{n_samples}^4)` space and
-    :math:`O(\\text{n_samples}^6 \\cdot \\text{n_features})` time.
+    This implementation creates a new set of samples by building the difference
+    between any two feature vectors in the original data. This approach
+    requires :math:`O(\text{n_samples}^4)` space and
+    :math:`O(\text{n_samples}^6 \cdot \text{n_features})` time, making it
+    computationally intensive for large datasets.
 
-    See :class:`sksurv.svm.NaiveSurvivalSVM` for the linear naive survival SVM based on liblinear.
+    The optimization problem is formulated as:
 
     .. math::
 
-          \\min_{\\mathbf{w}}\\quad
-          \\frac{1}{2} \\lVert \\mathbf{w} \\rVert_2^2
-          + \\gamma \\sum_{i = 1}^n \\xi_i \\\\
-          \\text{subject to}\\quad
-          \\mathbf{w}^\\top \\phi(\\mathbf{x})_i - \\mathbf{w}^\\top \\phi(\\mathbf{x})_j \\geq 1 - \\xi_{ij},\\quad
-          \\forall (i, j) \\in \\mathcal{P}, \\\\
-          \\xi_i \\geq 0,\\quad \\forall (i, j) \\in \\mathcal{P}.
+        \min_{\mathbf{w}}\quad
+        \frac{1}{2} \lVert \mathbf{w} \rVert_2^2
+        + \gamma \sum_{i = 1}^n \xi_i \\
+        \text{subject to}\quad
+        \mathbf{w}^\top \phi(\mathbf{x})_i - \mathbf{w}^\top \phi(\mathbf{x})_j \geq 1 - \xi_{ij},\quad
+        \forall (i, j) \in \mathcal{P}, \\
+        \xi_i \geq 0,\quad \forall (i, j) \in \mathcal{P}.
 
-          \\mathcal{P} = \\{ (i, j) \\mid y_i > y_j \\land \\delta_j = 1 \\}_{i,j=1,\\dots,n}.
+        \mathcal{P} = \{ (i, j) \mid y_i > y_j \land \delta_j = 1 \}_{i,j=1,\dots,n}.
 
     See [1]_, [2]_, [3]_ for further description.
 
     Parameters
     ----------
-    alpha : float, positive, default: 1
-        Weight of penalizing the hinge loss in the objective function.
+    alpha : float, optional, default: 1
+        Weight of penalizing the hinge loss in the objective function. Must be greater than 0.
 
     solver : {'ecos', 'osqp'}, optional, default: 'ecos'
         Which quadratic program solver to use.
 
-    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'cosine', 'precomputed'} or callable, default: 'linear'.
+    kernel : str or callable, optional, default: 'linear'
         Kernel mapping used internally. This parameter is directly passed to
         :func:`sklearn.metrics.pairwise.pairwise_kernels`.
         If `kernel` is a string, it must be one of the metrics
@@ -487,63 +569,67 @@ class HingeLossSurvivalSVM(MinlipSurvivalAnalysis):
         they operate on matrices, not single samples. Use the string
         identifying the kernel instead.
 
-    gamma : float, optional, default: None
+    gamma : float or None, optional, default: None
         Gamma parameter for the RBF, laplacian, polynomial, exponential chi2
         and sigmoid kernels. Interpretation of the default value is left to
         the kernel; see the documentation for :mod:`sklearn.metrics.pairwise`.
         Ignored by other kernels.
 
-    degree : int, default: 3
+    degree : int, optional, default: 3
         Degree of the polynomial kernel. Ignored by other kernels.
 
-    coef0 : float, optional
+    coef0 : float, optional, default: 1
         Zero coefficient for polynomial and sigmoid kernels.
         Ignored by other kernels.
 
-    kernel_params : mapping of string to any, optional
+    kernel_params : dict or None, optional, default: None
         Additional parameters (keyword arguments) for kernel function passed
         as callable object.
 
     pairs : {'all', 'nearest', 'next'}, optional, default: 'all'
         Which constraints to use in the optimization problem.
 
-        - all: Use all comparable pairs. Scales quadratic in number of samples.
+        - all: Use all comparable pairs. Scales quadratically in number of samples.
         - nearest: Only considers comparable pairs :math:`(i, j)` where :math:`j` is the
           uncensored sample with highest survival time smaller than :math:`y_i`.
-          Scales linear in number of samples (cf. :class:`sksurv.svm.MinlipSurvivalAnalysis`).
+          Scales linearly in number of samples (cf. :class:`sksurv.svm.MinlipSurvivalAnalysis`).
         - next: Only compare against direct nearest neighbor according to observed time,
-          disregarding its censoring status. Scales linear in number of samples.
+          disregarding its censoring status. Scales linearly in number of samples.
 
-    verbose : bool, default: False
-        Enable verbose output of solver.
+    verbose : bool, optional, default: False
+        If ``True``, enable verbose output of the solver.
 
-    timeit : False, int or None, default: None
-        If non-zero value is provided the time it takes for optimization is measured.
-        The given number of repetitions are performed. Results can be accessed from the
-        ``timings_`` attribute.
+    timeit : bool, int, or None, optional, default: False
+        If ``True`` or a non-zero integer, the time taken for optimization is measured.
+        If an integer is provided, the optimization is repeated that many times.
+        Results can be accessed from the ``timings_`` attribute.
 
     max_iter : int or None, optional, default: None
-        Maximum number of iterations to perform. By default
-        use solver's default value.
+        The maximum number of iterations taken for the solvers to converge.
+        If ``None``, use solver's default value.
 
     Attributes
     ----------
-    X_fit_ : ndarray
+    X_fit_ : ndarray, shape = (n_samples, `n_features_in_`)
         Training data.
 
-    coef_ : ndarray, shape = (n_samples,)
+    coef_ : ndarray, shape = (n_samples,), dtype = float
         Coefficients of the features in the decision function.
 
     n_features_in_ : int
         Number of features seen during ``fit``.
 
-    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+    feature_names_in_ : ndarray, shape = (`n_features_in_`,), dtype = object
         Names of features seen during ``fit``. Defined only when `X`
         has feature names that are all strings.
 
     n_iter_ : int
         Number of iterations run by the optimization routine to fit the model.
 
+    See also
+    --------
+    sksurv.svm.NaiveSurvivalSVM : The linear naive survival SVM based on liblinear.
+
     References
     ----------
     .. [1] Van Belle, V., Pelckmans, K., Suykens, J. A., & Van Huffel, S.

sksurv/svm/naive_survival_svm.py

@@ -24,61 +24,63 @@ from ..util import check_array_survival
 
 
 class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
-    """Naive version of linear Survival Support Vector Machine.
+    r"""Naive implementation of linear Survival Support Vector Machine.
 
-    Uses regular linear support vector classifier (liblinear).
-    A new set of samples is created by building the difference between any two feature
-    vectors in the original data, thus this version requires :math:`O(\\text{n_samples}^2)` space.
+    This class uses a regular linear support vector classifier (liblinear)
+    to implement a survival SVM. It constructs a new dataset by computing
+    the difference between feature vectors of comparable pairs from the
+    original data. This approach results in a space complexity of
+    :math:`O(\text{n_samples}^2)`.
 
-    See :class:`sksurv.svm.HingeLossSurvivalSVM` for the kernel naive survival SVM.
+    The optimization problem is formulated as:
 
     .. math::
 
-          \\min_{\\mathbf{w}}\\quad
-          \\frac{1}{2} \\lVert \\mathbf{w} \\rVert_2^2
-          + \\gamma \\sum_{i = 1}^n \\xi_i \\\\
-          \\text{subject to}\\quad
-          \\mathbf{w}^\\top \\mathbf{x}_i - \\mathbf{w}^\\top \\mathbf{x}_j \\geq 1 - \\xi_{ij},\\quad
-          \\forall (i, j) \\in \\mathcal{P}, \\\\
-          \\xi_i \\geq 0,\\quad \\forall (i, j) \\in \\mathcal{P}.
+        \min_{\mathbf{w}}\quad
+        \frac{1}{2} \lVert \mathbf{w} \rVert_2^2
+        + \gamma \sum_{i = 1}^n \xi_i \\
+        \text{subject to}\quad
+        \mathbf{w}^\top \mathbf{x}_i - \mathbf{w}^\top \mathbf{x}_j \geq 1 - \xi_{ij},\quad
+        \forall (i, j) \in \mathcal{P}, \\
+        \xi_i \geq 0,\quad \forall (i, j) \in \mathcal{P}.
 
-          \\mathcal{P} = \\{ (i, j) \\mid y_i > y_j \\land \\delta_j = 1 \\}_{i,j=1,\\dots,n}.
+        \mathcal{P} = \{ (i, j) \mid y_i > y_j \land \delta_j = 1 \}_{i,j=1,\dots,n}.
 
     See [1]_, [2]_ for further description.
 
     Parameters
     ----------
-    alpha : float, positive, default: 1.0
-        Weight of penalizing the squared hinge loss in the objective function.
+    alpha : float, optional, default: 1.0
+        Weight of penalizing the squared hinge loss in the objective function. Must be greater than 0.
 
-    loss : {'hinge', 'squared_hinge'}, default: 'squared_hinge'
+    loss : {'hinge', 'squared_hinge'}, optional,default: 'squared_hinge'
         Specifies the loss function. 'hinge' is the standard SVM loss
         (used e.g. by the SVC class) while 'squared_hinge' is the
         square of the hinge loss.
 
-    penalty : {'l1', 'l2'}, default: 'l2'
+    penalty : {'l1', 'l2'}, optional,default: 'l2'
         Specifies the norm used in the penalization. The 'l2'
         penalty is the standard used in SVC. The 'l1' leads to `coef_`
         vectors that are sparse.
 
-    dual : bool, default: True
+    dual : bool, optional,default: True
         Select the algorithm to either solve the dual or primal
         optimization problem. Prefer dual=False when n_samples > n_features.
 
     tol : float, optional, default: 1e-4
         Tolerance for stopping criteria.
 
-    verbose : int, default: 0
-        Enable verbose output. Note that this setting takes advantage of a
+    verbose : int, optional, default: 0
+        If ``True``, enable verbose output. Note that this setting takes advantage of a
         per-process runtime setting in liblinear that, if enabled, may not work
         properly in a multithreaded context.
 
-    random_state : int seed, RandomState instance, or None, default: None
-        The seed of the pseudo random number generator to use when
-        shuffling the data.
+    random_state : int, :class:`numpy.random.RandomState` instance, or None, optional, default: None
+        Used to resolve ties in survival times. Pass an int for reproducible output across
+        multiple :meth:`fit` calls.
 
-    max_iter : int, default: 1000
-        The maximum number of iterations to be run.
+    max_iter : int, optional, default: 1000
+        The maximum number of iterations taken for the solver to converge.
 
     Attributes
     ----------
@@ -87,8 +89,8 @@ class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
 
     See also
     --------
-    sksurv.svm.FastSurvivalSVM
-        Alternative implementation with reduced time complexity for training.
+    sksurv.svm.FastSurvivalSVM : Alternative implementation with reduced time complexity for training.
+    sksurv.svm.HingeLossSurvivalSVM : Non-linear version of the naive survival SVM based on kernel functions.
 
     References
     ----------
@@ -138,6 +140,30 @@ class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
         self.alpha = alpha
 
     def _get_survival_pairs(self, X, y, random_state):  # pylint: disable=no-self-use
+        """Generates comparable pairs from survival data.
+
+        Parameters
+        ----------
+        X : array-like, shape = (n_samples, n_features)
+            Data matrix.
+        y : structured array, shape = (n_samples,)
+            A structured array containing the binary event indicator
+            and time of event or time of censoring.
+        random_state : RandomState instance
+            Random number generator used for shuffling.
+
+        Returns
+        -------
+        x_pairs : ndarray, shape = (n_pairs, n_features)
+            Feature differences for comparable pairs.
+        y_pairs : ndarray, shape = (n_pairs,)
+            Labels for comparable pairs (1 or -1).
+
+        Raises
+        ------
+        NoComparablePairException
+            If no comparable pairs can be formed from the input data.
+        """
         feature_names = _get_feature_names(X)
 
         X = validate_data(self, X, ensure_min_samples=2)
@@ -180,9 +206,9 @@ class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
             Data matrix.
 
         y : structured array, shape = (n_samples,)
-            A structured array containing the binary event indicator
-            as first field, and time of event or time of censoring as
-            second field.
+            A structured array with two fields. The first field is a boolean
+            where ``True`` indicates an event and ``False`` indicates right-censoring.
+            The second field is a float with the time of event or time of censoring.
 
         sample_weight : array-like, shape = (n_samples,), optional
             Array of weights that are assigned to individual
@@ -203,9 +229,12 @@ class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
         return super().fit(x_pairs, y_pairs, sample_weight=sample_weight)
 
     def predict(self, X):
-        """Rank samples according to survival times
+        """Predict risk scores.
 
-        Lower ranks indicate shorter survival, higher ranks longer survival.
+        Predictions are risk scores (i.e. higher values indicate an
+        increased risk of experiencing an event). The scores have no
+        unit and are only meaningful to rank samples by their risk
+        of experiencing an event.
 
         Parameters
         ----------
@@ -214,7 +243,7 @@ class NaiveSurvivalSVM(SurvivalAnalysisMixin, LinearSVC):
 
         Returns
         -------
-        y : ndarray, shape = (n_samples,)
-            Predicted ranks.
+        y : ndarray, shape = (n_samples,), dtype = float
+            Predicted risk scores.
         """
         return -self.decision_function(X)