cenreg.pytorch package

Submodules

cenreg.pytorch.cjd2F module

class cenreg.pytorch.cjd2F.MseModel(jd_pred: array, copula, learning_rate: float = 0.01, focal_risk: int = -1, init_f: ndarray = None, optimizer=None)

Bases: Module

configure_optimizers()
forward()

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

loss()
cenreg.pytorch.cjd2F.minimize_mse(model, num_epochs: int) → ndarray

Estimate marginal distribution from joint distribution.

Parameters:

  • model (pytorch model)

  • num_epochs (int) – Number of epochs.

Returns:

F_pred – np.ndarray of shape [batch_size, num_risks, num_bin_predictions+1]

Return type:

estimated CDF.

cenreg.pytorch.copula_torch module

class cenreg.pytorch.copula_torch.ClaytonCopula(theta: Tensor)

Bases: object

Clayton copula implemented with pytorch.

cdf(u: Tensor) → Tensor
Parameters:

u (torch.Tensor (float)) – Each element should be in [0, 1].

Returns:

probability

Return type:

torch.Tensor (float)

class cenreg.pytorch.copula_torch.FrankCopula(theta: Tensor)

Bases: object

Frank copula implemented with pytorch.

cdf(u: Tensor) → Tensor
class cenreg.pytorch.copula_torch.GumbelCopula(theta: Tensor)

Bases: object

Gumbel copula implemented with pytorch.

cdf(u: Tensor) → Tensor
class cenreg.pytorch.copula_torch.IndependenceCopula

Bases: object

Independence copula implemented with pytorch.

cdf(u: Tensor) → Tensor
Parameters:

u (torch.Tensor (float)) – tensor of shape [batch_size, 2]. Each element should be in [0, 1].

Returns:

probability – tensor of shape [batch_size].

Return type:

torch.Tensor (float)

class cenreg.pytorch.copula_torch.SurvivalCopula(copula)

Bases: object

Survival copula implemented with pytorch.

cdf(u: Tensor) → Tensor
cenreg.pytorch.copula_torch.create(name: str, theta: float = 0.0)

Create a copula object based on the name and theta parameter. :param name: Name of the copula. Options are “independence” and “frank”. :type name: str :param theta: Parameter for the copula. Default is 0.0. :type theta: float

Returns:

An instance of the Copula class.

Return type:

copula

cenreg.pytorch.datamodule module

class cenreg.pytorch.datamodule.ProbDataModule(batch_size)

Bases: Dataset

test_dataloader(features, targets)
train_dataloader(features, targets)
val_dataloader(features, targets)
class cenreg.pytorch.datamodule.ProbDataset(features, targets)

Bases: Dataset

len_feature()
class cenreg.pytorch.datamodule.SurvDataModule(batch_size)

Bases: Dataset

test_dataloader(features, observed_times, events)
train_dataloader(features, observed_times, events)
val_dataloader(features, observed_times, events)
class cenreg.pytorch.datamodule.SurvDataset(features, observed_times, events)

Bases: Dataset

len_feature()

cenreg.pytorch.distribution module

class cenreg.pytorch.distribution.LinearCDF(boundaries: Tensor, values: Tensor = None, apply_cumsum: bool = True)

Bases: object

Distribution functions with linear interpolation.

A distribution function is represented as a discrete cumulative distribution function (CDF) at pre-defined quantile levels (boundaries). The values between probabilities are computed by using linear interpolation.

If qk_values are two-dimensional tensor, then each row corresponds to a CDF.

average_cdf(y, mask=None, add_edge=False)
cdf(y, mask=None, add_edges=False)

Cumulative distribution function (i.e., inverse of quantile function).

Parameters:

  • y (Tensor) – CDF values are computed for values y. If dimension of y is one, then cdf(y) is computed for all CDFs. If dimension of y is two, then cdf(y) is computed for each corresponding CDF.

  • mask (Tensor) – Mask to compute CDF for a subset of CDFs. Tensor must be one-dimensional and its length must be equal to the number of CDFs.

  • add_edges (bool) – If True, then the CDF values at the boundaries are added.

Returns:

cdf_values – Compute CDF values for each value in y. Tensor shape is equal to the shape of y.

Return type:

Tensor

get_boundary_lengths()
icdf(alpha, mask=None, add_edges=False)

Quantile function (i.e., inverse of cumulative distribution function).

Parameters:

  • alpha (Tensor) – Quantile values are computed for quantile levels alpha. If dimension of alpha is one, then icdf(alpha) is computed for all CDFs. If dimension of alpha is two, then icdf(alpha) is computed for each corresponding CDF.

  • mask (Tensor) – Mask to compute CDF for a subset of CDFs. Tensor must be one-dimensional and its length must be equal to the number of CDFs.

  • add_edges (bool) – If True, then the inverse of the CDF values at the boundaries are added.

Returns:

y – Compute y. Tensor shape is equal to the shape of alpha.

Return type:

Tensor

set_knot_values(values, apply_cumsum=True)

Set values of CDF values.

Parameters:

  • values (Tensor) – One or two-dimensional tensor containing the values of CDFs. If cdf_values is two-dimensional tensor, then each row corresponds to a CDF and cdf_values[:,j] stores the value of CDF at boundries[j]. Tensor shape must be [num_CDF, len(boundaries)].

  • apply_cumsum (bool) – If True, then cdf_values is assumed to be the probablity distribution functions (PDFs) and the cumulative sum of cdf_values is computed.

class cenreg.pytorch.distribution.LinearQuantileFunction(qk_levels: Tensor, qk_values: Tensor = None, apply_cumsum: bool = True)

Bases: object

Quantile functions with linear interpolation.

A quantile function is defined by a set of quantile values (qk_values) at pre-defined quantile levels (qk_levels). The values between quantile values are computed by using linear interpolation.

If qk_values are two-dimensional tensor, then each row corresponds to a quantile function.

average_cdf(y, mask=None, add_edge=False)
cdf(y, mask=None, add_edges=False)

Cumulative distribution function (i.e., inverse of quantile function).

Parameters:

  • y (Tensor) – Quantile levels are computed for quantile values y. If dimension of y is one, then cdf(y) is computed for all quantile functions. If dimension of y is two, then cdf(y) is computed for each corresponding quantile function.

  • mask (Tensor) – Mask to compute quantile function for a subset of quantile functions. Tensor must be one-dimensional and its length must be equal to the number of quantile functions.

  • add_edges (bool) – If True, then the CDF values at the boundaries are added.

Returns:

q_levels – Compute quantile levels for each value in y. Tensor shape is equal to the shape of y.

Return type:

Tensor

get_qk_lengths()
icdf(alpha, mask=None, add_edges=False)

Quantile function (i.e., inverse of cumulative distribution function).

Parameters:

  • alpha (Tensor) – Quantile values are computed for quantile levels alpha. If dimension of alpha is one, then icdf(alpha) is computed for all quantile functions. If dimension of alpha is two, then icdf(alpha) is computed for each corresponding quantile function.

  • mask (Tensor) – Mask to compute quantile function for a subset of quantile functions. Tensor must be one-dimensional and its length must be equal to the number of quantile functions.

  • add_edges (bool) – If True, then the inverse of the CDF values at the boundaries are added.

Returns:

y – Compute y. Tensor shape is equal to the shape of alpha.

Return type:

Tensor

set_knot_values(qk_values, apply_cumsum=True)

Set values of quantile knots.

Parameters:

  • qk_values (Tensor) – One or two-dimensional tensor containing the values of quantile knots. If qk_values is two-dimensional tensor, then each row corresponds to a quantile function and qk_values[:,j] stores the value of quantile function at qk_levels[j]. Tensor shape must be [num_quantile_function, len(qk_levels)].

  • apply_cumsum (bool) – If True, then qk_values is assumed to be the differences of quantile values and the cumulative sum of qk_values is computed.

cenreg.pytorch.loss_cdf module

class cenreg.pytorch.loss_cdf.Brier(y_bins: Tensor, apply_cumsum: bool = True)

Bases: object

Loss class for the Brier score.

loss(pred: Tensor, y: Tensor) → Tensor
class cenreg.pytorch.loss_cdf.CNLL_CR(boundaries: Tensor, num_risks: int)

Bases: object

Censored Negative Log Likelihood for Competing Risks

loss(pred: Tensor, observed_times: Tensor, events: Tensor) → Tensor
class cenreg.pytorch.loss_cdf.NegativeLogLikelihood(y_bins: Tensor, apply_cumsum: bool = True)

Bases: object

Loss class for negative log-likelihood.

loss(pred: Tensor, y: Tensor, uncensored: Tensor = None) → Tensor
class cenreg.pytorch.loss_cdf.RankedProbabilityScore(y_bins: Tensor, apply_cumsum: bool = True)

Bases: object

Loss class for the ranked probability score.

loss(pred: Tensor, y: Tensor) → Tensor
cenreg.pytorch.loss_cdf.brier(dist, y: Tensor, y_bins: Tensor = None) → Tensor

Compute the Brier score.

Parameters:

  • dist (predicted distribution)

  • y (Tensor of shape [batch_size])

  • y_bins (Tensor of shape [num_bin+1])

Returns:

loss

Return type:

Tensor of shape [batch_size]

cenreg.pytorch.loss_cdf.negative_log_likelihood(dist, y: Tensor, y_bins: Tensor = None, uncensored: Tensor = None, EPS: float = 0.0001) → Tensor

Compute Negative log-likelihood.

Parameters:

  • dist (predicted distribution)

  • y (Tensor of shape [batch_size, 1])

  • y_bins (Tensor of shape [num_bins+1])

  • uncensored (Tensor of shape [batch_size])

  • EPS (float)

Returns:

loss

Return type:

Tensor of shape [batch_size]

cenreg.pytorch.loss_cdf.ranked_probability_score(dist, y: Tensor, y_bins: Tensor) → Tensor

Compute the ranked probability score.

Parameters:

  • dist (predicted distribution)

  • y (Tensor of shape [batch_size])

  • y_bins (Tensor of shape [num_bins+1])

Returns:

loss

Return type:

Tensor of shape [batch_size]

cenreg.pytorch.loss_cjd module

class cenreg.pytorch.loss_cjd.Brier(y_bins: Tensor, num_risks: int)

Bases: object

loss(pred: Tensor, observed_times: Tensor, events: Tensor) → Tensor
class cenreg.pytorch.loss_cjd.NegativeLogLikelihood(y_bins: Tensor, num_risks: int, EPS: float = 0.0001)

Bases: object

loss(pred: Tensor, observed_times: Tensor, events: Tensor) → Tensor
class cenreg.pytorch.loss_cjd.RankedProbabilityScore(y_bins: Tensor, num_risks: int)

Bases: object

loss(f_pred: Tensor, observed_times: Tensor, events: Tensor) → Tensor

cenreg.pytorch.loss_cont module

class cenreg.pytorch.loss_cont.CopulaNegativeLogLikelihood(copula=None, survival_copula=None, EPS=0.0001)

Bases: object

Negative Log Likelihood with survival copula

return -log ((dC/dF) (dF/dt))

loss(F_pred: Tensor, observed_times: Tensor, events: Tensor) → Tensor
class cenreg.pytorch.loss_cont.NegativeLogLikelihood(EPS=0.0001)

Bases: object

Negative Log-Likelihood

loss(F_pred: Tensor, observed_times: Tensor, events: Tensor = None) → Tensor

cenreg.pytorch.mlp module

class cenreg.pytorch.mlp.Linear(output_len: int)

Bases: Module

Single Layer Perceptron

forward(x: Tensor)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class cenreg.pytorch.mlp.MLP(input_len: int, output_len: int, num_neuron: int)

Bases: Module

Multi Layer Perceptron

forward(x: Tensor)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class cenreg.pytorch.mlp.MLP_MultiHead(input_len: int, output_len: int, output_num: int, num_neuron: int, use_softmax: bool = True)

Bases: Module

Multi Layer Perceptron with Multiple Outputs

forward(x: Tensor)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class cenreg.pytorch.mlp.SMM(embed_size: int)

Bases: Module

Fully monotonic neural network. The output y is a function of input x, and the function is monotonic with respect to all dimensions of x.

forward(x: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class cenreg.pytorch.mlp.SMM_MultiHead(input_len: int, input_monotone_len: int, output_num: int, num_neuron: int)

Bases: Module

forward(x: Tensor, t: Tensor) → Tensor

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

cenreg.pytorch.utils module

cenreg.pytorch.utils.denormalize_pred(pred: Tensor, min_y: float, max_y: float) → Tensor

Denormalize the predictions using the min and max values.

Parameters:

  • pred (torch.Tensor) – The normalized predictions.

  • min_y (float) – The minimum values for denormalization.

  • max_y (float) – The maximum values for denormalization.

Returns:

denormalized_prediction – The denormalized predictions.

Return type:

torch.Tensor

cenreg.pytorch.utils.normalize_y(y: Tensor, min_y: float, max_y: float) → Tensor

Normalize the input tensor using the min and max values.

Parameters:

  • y (torch.Tensor) – The input tensor to be normalized.

  • min_y (float) – The minimum values for normalization.

  • max_y (float) – The maximum values for normalization.

Returns:

normalized_tensor – The normalized tensor.

Return type:

torch.Tensor

Module contents