dicePixelClassificationLayer

(To be removed) Create pixel classification layer using generalized Dice loss for semantic segmentation

The DicePixelClassificationLayer object will be removed in a future release. Use the trainnet (Deep Learning Toolbox) function and specify the loss using the generalizedDice function. For more information, see Version History.

Description

A Dice pixel classification layer provides a categorical label for each image pixel or voxel using generalized Dice loss.

The layer uses generalized Dice loss to alleviate the problem of class imbalance in semantic segmentation problems. Generalized Dice loss controls the contribution that each class makes to the loss by weighting classes by the inverse size of the expected region.

Creation

Syntax

layer = dicePixelClassificationLayer

layer = dicePixelClassificationLayer(Name,Value)

Description

layer = dicePixelClassificationLayer creates a Dice pixel classification output layer for semantic image segmentation networks. The layer outputs the categorical label for each image pixel or voxel processed by a CNN. The layer automatically ignores undefined pixel labels during training.

layer = dicePixelClassificationLayer(Name,Value) returns a Dice pixel classification output layer using name-value arguments to set the optional Classes and Name properties. You can specify multiple name-value arguments.

For example, dicePixelClassificationLayer("Name","pixclass") creates a Dice pixel classification layer with the name "pixclass".

Properties

Classes — Classes of the output layer

"auto" (default) | categorical vector | string array | cell array of character vectors

Classes of the output layer, specified as a categorical vector, string array, cell array of character vectors, or "auto". If Classes is "auto", then the software automatically sets the classes at training time. If you specify the string array or cell array of character vectors str, then the software sets the classes of the output layer to categorical(str,str).

Data Types: char | categorical | string | cell

OutputSize — Output size

'auto' (default)

This property is read-only.

The output size of the layer. The value is 'auto' prior to training, and is specified as a numeric value at training time.

LossFunction — Loss function

'generalizedDiceLoss' (default)

This property is read-only.

Loss function used for training, specified as 'generalizedDiceLoss'.

Name — Layer name

"" (default) | character vector | string scalar

Layer name, specified as a character vector or string scalar. For Layer array input, the trainnet (Deep Learning Toolbox) and dlnetwork (Deep Learning Toolbox) functions automatically assign names to layers with the name "".

The DicePixelClassificationLayer object stores this property as a character vector.

Data Types: char | string

NumInputs — Number of inputs

1 (default)

This property is read-only.

Number of inputs to the layer, returned as 1. This layer accepts a single input only.

Data Types: double

InputNames — Input names

{'in'} (default)

This property is read-only.

Input names, returned as {'in'}. This layer accepts a single input only.

Data Types: cell

Examples

Create 2-D Semantic Segmentation Network with Dice Pixel Classification Layer

Predict the categorical label of every pixel in an input image using a generalized Dice loss function.

layers = [
      imageInputLayer([480 640 3])
      convolution2dLayer(3,16,'Stride',2,'Padding',1)
      reluLayer
      transposedConv2dLayer(2,4,'Stride',2)
      softmaxLayer
      dicePixelClassificationLayer
      ]  

layers = 
  6x1 Layer array with layers:

     1   ''   Image Input                       480x640x3 images with 'zerocenter' normalization
     2   ''   2-D Convolution                   16 3x3 convolutions with stride [2  2] and padding [1  1  1  1]
     3   ''   ReLU                              ReLU
     4   ''   2-D Transposed Convolution        4 2x2 transposed convolutions with stride [2  2] and cropping [0  0  0  0]
     5   ''   Softmax                           softmax
     6   ''   Dice Pixel Classification Layer   Generalized Dice loss 

More About

Dice Loss

The Dice loss function is based on the Sørensen-Dice similarity coefficient for measuring overlap between two segmented images.

The generalized Dice loss function L used by dicePixelClassificationLayer for the loss between one image Y and the corresponding ground truth T is given by:

$$L=1-\frac{2{\displaystyle {\sum }_{k=1}^K{w}_k}{\displaystyle {\sum }_{m=1}^M{Y}_{km}{T}_{km}}}{{\displaystyle {\sum }_{k=1}^K{w}_k}{\displaystyle {\sum }_{m=1}^M{Y}_{km}^2+T_{km}^2}}$$

K is the number of classes, M is the number of elements along the first two dimensions of Y, and w_k is a class specific weighting factor that controls the contribution each class makes to the loss. This weighting helps counter the influence of larger regions on the Dice score, making it easier for the network to learn how to segment smaller regions. w_k is typically the inverse area of the expected region:

$$w_k=\frac{1}{{\left({\displaystyle {\sum }_{m=1}^M{T}_{km}}\right)}^2}$$

There are several variations of generalized Dice Loss functions [1], [2]. The function used in dicePixelClassificationLayer has squared terms to ensure that the derivative is 0 when the prediction matches the ground truth [3].

References

[1] Crum, William R., Oscar Camara, and Derek LG Hill. "Generalized overlap measures for evaluation and validation in medical image analysis." IEEE Transactions on Medical Imaging. 25.11, 2006, pp. 1451–1461.

[2] Sudre, Carole H., et al. "Generalised Dice overlap as a deep learning loss function for highly unbalanced segmentations." Deep Learning in Medical Image Analysis and Multimodal Learning for Clinical Decision Support. Springer, Cham, 2017, pp. 240–248.

[3] Milletari, Fausto, Nassir Navab, and Seyed-Ahmad Ahmadi. "V-Net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation". Fourth International Conference on 3D Vision (3DV). Stanford, CA, 2016: pp. 565–571.

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

The code generator represents characters in an 8-bit ASCII codeset that the locale setting determines. Therefore, the use of non-ASCII characters in class names, layer names, layer description, or network names might result in errors. For more information, see Encoding of Characters in Code Generation (MATLAB Coder).

GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Usage notes and limitations:

• To generate CUDA^® or C++ code by using GPU Coder™, you must first construct and train a deep neural network. Once the network is trained and evaluated, you can configure the code generator to generate code and deploy the convolutional neural network on platforms that use NVIDIA^® or ARM^® GPU processors. For more information, see Deep Learning with GPU Coder (GPU Coder).

• For this layer, you can generate code that takes advantage of the NVIDIA CUDA deep neural network library (cuDNN), NVIDIA TensorRT™ high performance inference library, or the ARM Compute Library for Mali GPU.

• The code generator represents characters in an 8-bit ASCII codeset that the locale setting determines. Therefore, the use of non-ASCII characters in class names, layer names, layer description, or network names might result in errors. For more information, see Encoding of Characters in Code Generation (MATLAB Coder).

Version History

Introduced in R2019b

R2024a: dicePixelClassificationLayer will be removed

The dicePixelClassificationLayer object will be removed in a future release. Follow these steps to update your code:

• Define your network as a dlnetwork (Deep Learning Toolbox) object. You can use functions such as addLayers (Deep Learning Toolbox) and connectLayers (Deep Learning Toolbox) to build the network. Do not include output layers in the network.

• Define a custom loss function that uses the generalizedDice function. Here is a sample loss function appropriate for Dice pixel classification:

  function loss = modelLoss(Y,T)
    z = generalizedDice(Y,T); 
    loss = 1 - mean(z,"all"); 
  end

• Train the network using the trainnet (Deep Learning Toolbox) function with the custom loss function. For example, this code trains a dlnetwork network called net using the training data images and the custom loss function modelLoss.

  netTrained = trainnet(images,net,@modelLoss,options);