fixed PR issue

Author: tcoroller

.pre-commit-config.yaml

@@ -26,7 +26,6 @@ repos:
       - id: codespell
         additional_dependencies: [tomli]
         args: ["--write-changes"]
-        exclude: '\.(ipynb|bib|toml)$'  # Exclude notebooks and other files with false positives
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.12.4

docs/notebooks/introduction.ipynb

@@ -36,7 +36,7 @@ def neg_partial_time_log_likelihood(
         tensor(0.9452, grad_fn=<DivBackward0>)
         >>> neg_partial_time_log_likelihood(estimates.squeeze(), time, event)  # Also works with 2D tensor
         tensor(0.9452, grad_fn=<DivBackward0>)
-        >>> neg_partial_time_log_likelihood(estimates, time, event, reduction='sum')
+        >>> neg_partial_time_log_likelihood(estimates, time, event, reduction="sum")
         tensor(37.8082, grad_fn=<SumBackward0>)
         >>> from torchsurv.metrics.cindex import ConcordanceIndex
         >>> cindex = ConcordanceIndex()
@@ -47,7 +47,7 @@ def neg_partial_time_log_likelihood(
         tensor(0.4545)
     """
 
-    # only consider theta at tiem of
+    # only consider theta at time of
     pll = _partial_likelihood_time_cox(log_hz, time, events)
 
     # Negative partial log likelihood
@@ -57,11 +57,7 @@ def neg_partial_time_log_likelihood(
     elif reduction.lower() == "sum":
         loss = pll.sum()
     else:
-        raise (
-            ValueError(
-                f"Reduction {reduction} is not implemented yet, should be one of ['mean', 'sum']."
-            )
-        )
+        raise (ValueError(f"Reduction {reduction} is not implemented yet, should be one of ['mean', 'sum']."))
     return loss
 
 
@@ -79,7 +75,7 @@ def _partial_likelihood_time_cox(
             Log relative hazard of dimension T x n_samples x P.
             T is the time series dimension, P is the number of parameters observed over time.
         event (torch.Tensor, bool):
-            Event indicator of length n_samples (= True if event occured).
+            Event indicator of length n_samples (= True if event occurred).
         time (torch.Tensor):
             Time-to-event or censoring of length n_samples.
 
@@ -88,32 +84,32 @@ def _partial_likelihood_time_cox(
             Vector of the partial log likelihood, length n_samples.
 
     Note:
-        For each subject :math:`i \in \{1, \cdots, N\}`, denote :math:`\tau^*_i` as the survival time and :math:`C_i` as the
-        censoring time. Survival data consist of the event indicator, :math:`\delta_i=1(\tau^*_i\leq C_i)`
-        (argument ``event``) and the time-to-event or censoring, :math:`\tau_i = \min(\{ \tau^*_i,D_i \})`
+        For each subject :math:`i \\in \\{1, \\cdots, N\\}`, denote :math:`\tau^*_i` as the survival time and :math:`C_i` as the
+        censoring time. Survival data consist of the event indicator, :math:`\\delta_i=1(\tau^*_i\\leq C_i)`
+        (argument ``event``) and the time-to-event or censoring, :math:`\tau_i = \\min(\\{ \tau^*_i,D_i \\})`
         (argument ``time``).
 
         Consider some covariate :math:`Z(t)` with covariate history denoted as :math:`H_Z` and a general form of the cox proportional hazards model:
             .. math::
 
-            \log \lambda_i (t|H_Z) = lambda_0(t) \theta(Z(t))
+            \\log \\lambda_i (t|H_Z) = lambda_0(t) \theta(Z(t))
 
-        A network that maps the input covariates $Z(t)$ to the log relative hazards: :math:`\log \theta(Z(t))`.
-        The partial likelihood with repsect to  :math:`\log \theta(Z(t))` is written as:
+        A network that maps the input covariates $Z(t)$ to the log relative hazards: :math:`\\log \theta(Z(t))`.
+        The partial likelihood with respect to  :math:`\\log \theta(Z(t))` is written as:
 
             .. math::
 
-             \log L(\theta) = \sum_j \Big( \log \theta(Z_i(\tau_j)) - \log [\sum_{j \in R_i} \theta (Z_i(\tau_j))] \Big)
+             \\log L(\theta) = \\sum_j \\Big( \\log \theta(Z_i(\tau_j)) - \\log [\\sum_{j \\in R_i} \theta (Z_i(\tau_j))] \\Big)
 
         and it only considers the values of te covariate :math:`Z` at event time :math:`\tau_i`
 
     Remarks:
     - values inside the time vector must be strictly zero or positive as they are used to identify values of
         covariates at event time
-    - the maximum value inside the vector time cannt exceed T-1 for indexing reasons
-    - this function was not tested for P>1 but it should be possile for an extension
+    - the maximum value inside the vector time cannot exceed T-1 for indexing reasons
+    - this function was not tested for P>1 but it should be possible for an extension
     - the values of Z at event time should not be null, a reasonable imputation method should be used,
-        unless the network fullfills that role
+        unless the network fulfills that role
     - future formatting: time vector must somehow correspond to the T dimension in the log_hz tensor, i.e. for those who experience an event,
         we want to identify the index of the covariate upon failure. We could either consider the last covariate before a series of zeros
         (requires special data formatting but could reduce issues as it automatically contains event time information).
@@ -170,32 +166,17 @@ def _time_varying_covariance(
     # sort data by time-to-event or censoring
     time_sorted, idx = torch.sort(time)
     log_hz_sorted = log_hz[idx]
-    event_sorted = event[idx]
 
     # keep log if we can
     exp_log_hz = torch.exp(log_hz_sorted)
     # remove mean over time from covariates
     # sort covariates so that the rows match the ordering
     covariates_sorted = covariates[idx, :] - covariates.mean(dim=0)
 
-    # the left hand side (HS) of the equation
-    # below is Z_k Z_k^T - i think it should be a vector matrix dim nxn
-    covariate_inner_product = torch.matmul(covariates_sorted, covariates_sorted.T)
-
-    # pointwise multiplication of vectors to get the nominator of left HS
-    # outcome in a vector of length n
-    # Ends up being (1, n)
-    log_nominator_left = torch.matmul(exp_log_hz.T, covariate_inner_product)
-
     # right hand size of the equation
     # formulate the brackets \sum exp(theta)Z_k
     bracket = torch.mul(exp_log_hz, covariates_sorted)
     covariance_matrix = torch.matmul(bracket, bracket.T)  # nxn matrix
-    # ###nbelow is commented out as it does not apply but I wanted to keep it for the functions
-    # #log_nominator_right = torch.sum(nominator_right, dim=0).unsqueeze(0)
-    # log_nominator_right = nominator_right[0,].unsqueeze(0)
-    # log_denominator = torch.logcumsumexp(log_hz_sorted.flip(0), dim=0).flip(0) #dim=0 sums over the oth dimension
-    # partial_log_likelihood = torch.div(log_nominator_left - log_nominator_right, log_denominator) # (n, n)
 
     return covariance_matrix