minerva.losses.dice

Attributes

BINARY_MODE
MULTICLASS_MODE
MULTILABEL_MODE

Classes

DiceLoss

Base class for all neural network modules.

Module Contents

minerva.losses.dice.BINARY_MODE = 'binary'

class minerva.losses.dice.DiceLoss(mode, classes=None, log_loss=False, from_logits=True, smooth=0.0, ignore_index=None, eps=1e-07)

Bases: torch.nn.modules.loss._Loss

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

Parameters:

• mode (str)

• classes (Optional[List[int]])

• log_loss (bool)

• from_logits (bool)

• smooth (float)

• ignore_index (Optional[int])

• eps (float)

Initialize the DiceLoss class.

Parameters

modestr

Loss mode. Valid options are ‘binary’, ‘multiclass’, or ‘multilabel’.

classesOptional[List[int]], optional

List of classes that contribute in loss computation. By default, all channels are included. By default None

log_lossbool, optional

If True, loss is computed as - log(dice_coeff). If False, loss is computed as 1 - dice_coeff, by default False

from_logitsbool, optional

If True, assumes input is raw logits. If False, assumes input is probabilities., by default True

smoothfloat, optional

Smoothness constant for dice coefficient (a), by default 0.0

ignore_indexOptional[int], optional

Label that indicates ignored pixels (does not contribute to loss), by default None

epsfloat, optional

A small epsilon for numerical stability to avoid zero division error (denominator will be always greater or equal to eps), by default 1e-7

Raises

AssertionError

If the mode is not one of ‘binary’, ‘multiclass’, or ‘multilabel’ and classes are being masked with mode=’binary’.

aggregate_loss(loss)

classes = None

compute_score(output, target, smooth=0.0, eps=1e-07, dims=None)

Return type:

torch.Tensor

eps = 1e-07

forward(y_pred, y_true)

Parameters:

• y_pred (torch.Tensor)

• y_true (torch.Tensor)

Return type:

torch.Tensor

from_logits = True

ignore_index = None

log_loss = False

mode

smooth = 0.0

minerva.losses.dice.MULTICLASS_MODE = 'multiclass'

minerva.losses.dice.MULTILABEL_MODE = 'multilabel'