nn-common-modules’s documentation!

Note

Common modules, blocks and losses which can be reused in a deep neural netwok specifically for segmentation.

1. Losses

Description

Addition losses module defines classses which are commonly used particularly in segmentation and are not part of standard pytorch library.

Usage

Import the package and Instantiate any loss class you want to you:

from nn_common_modules import losses as additional_losses
loss = additional_losses.DiceLoss()

Members

class losses.CombinedLoss

A combination of dice and cross entropy loss

forward(input, target, weight=None)

Forward pass

Parameters:
  • input – torch.tensor (NxCxHxW)
  • target – torch.tensor (NxHxW)
  • weight – torch.tensor (NxHxW)
Returns:

scalar
class losses.CrossEntropyLoss2d(weight=None)

Standard pytorch weighted nn.CrossEntropyLoss

forward(inputs, targets)

Forward pass

Parameters:
  • inputs – torch.tensor (NxC)
  • targets – torch.tensor (N)
Returns:

scalar
class losses.DiceLoss(weight=None, size_average=None, reduce=None, reduction='mean')

Dice Loss for a batch of samples

forward(output, target, weights=None, ignore_index=None, binary=False)

Forward pass

Parameters:
  • output – NxCxHxW logits
  • target – NxHxW LongTensor
  • weights – C FloatTensor
  • ignore_index – int index to ignore from loss
  • binary – bool for binarized one chaneel(C=1) input
Returns:

torch.tensor
class losses.FocalLoss(gamma=2, alpha=None, size_average=True)

Focal Loss for Dense Object Detection

forward(input, target)

Forward pass

Parameters:
  • input (torch.tensor) – shape = NxCxHxW
  • target (torch.tensor) – shape = NxHxW
Returns:

loss value
Return type:

torch.tensor
class losses.IoULoss(weight=None, size_average=None, reduce=None, reduction='mean')

IoU Loss for a batch of samples

forward(output, target, weights=None, ignore_index=None)

Forward pass

Parameters:
  • output (torch.tensor [FloatTensor]) – shape = NxCxHxW
  • target (torch.tensor [LongTensor]) – shape = NxHxW
  • weights (torch.tensor [FloatTensor], optional) – shape = C, defaults to None
  • ignore_index (int, optional) – index to ignore from loss, defaults to None
Returns:

loss value
Return type:

torch.tensor

2. Modules

Description

Building blocks of segmentation neural network

Usage

Import the package and Instantiate any module/block class you want to you:

from nn_common_modules import modules as additional_modules
dense_block = additional_modules.DenseBlock(params, se_block_type = 'SSE')

Members

class modules.ClassifierBlock(params)

Last layer

Parameters:params (dict) –

{ ‘num_channels’:1, ‘num_filters’:64, ‘kernel_c’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}
Returns:forward passed tensor
Return type:torch.tensor [FloatTensor]
forward(input, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • weights (torch.tensor (N), optional) – Weights for classifier regression, defaults to None
Returns:

logits
Return type:

torch.tensor
class modules.DecoderBlock(params, se_block_type=None)

Dense decoder block with maxunpool and an optional skip connections and SE block

Parameters:
  • params (dict) –

    { ‘num_channels’:1, ‘num_filters’:64, ‘kernel_h’:5, ‘kernel_w’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}

  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

forward passed tensor
Return type:

torch.tensor [FloatTensor]
forward(input, out_block=None, indices=None, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • out_block (torch.tensor [FloatTensor], optional) – Tensor for skip connection, shape = (N x C x H x W), defaults to None
  • indices (torch.tensor, optional) – Indices used for unpooling operation, defaults to None
  • weights (torch.tensor, optional) – Weights used for squeeze and excitation, shape depends on the type of SE block, defaults to None
Returns:

Forward passed tensor
Return type:

torch.tensor [FloatTensor]
class modules.DenseBlock(params, se_block_type=None)

Block with dense connections

Parameters:
  • params (dict) –

    { ‘num_channels’:1, ‘num_filters’:64, ‘kernel_h’:5, ‘kernel_w’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}

  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

forward passed tensor
Return type:

torch.tonsor [FloatTensor]
forward(input)

Forward pass

Parameters:input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
Returns:Forward passed tensor
Return type:torch.tensor [FloatTensor]
class modules.EncoderBlock(params, se_block_type=None)

Dense encoder block with maxpool and an optional SE block

Parameters:
  • params (dict) –

    { ‘num_channels’:1, ‘num_filters’:64, ‘kernel_h’:5, ‘kernel_w’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}

  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

output tensor with maxpool, output tensor without maxpool, indices for unpooling
Return type:

torch.tensor [FloatTensor], torch.tensor [FloatTensor], torch.tensor [LongTensor]
forward(input, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • weights (torch.tensor, optional) – Weights used for squeeze and excitation, shape depends on the type of SE block, defaults to None
Returns:

output tensor with maxpool, output tensor without maxpool, indices for unpooling
Return type:

torch.tensor [FloatTensor], torch.tensor [FloatTensor], torch.tensor [LongTensor]
class modules.GenericBlock(params, se_block_type=None)

Generic parent class for a conv encoder/decoder block.

Parameters:
  • params (dict) – {‘kernel_h’: 5 ‘kernel_w’: 5 ‘num_channels’:64 ‘num_filters’:64 ‘stride_conv’:1 }
  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

forward passed tensor
Return type:

torch.tensor [FloatTensor]
forward(input, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • weights (torch.tensor [FloatTensor], optional) – Custom weights for convolution, defaults to None
Returns:

[description]
Return type:

[type]
class modules.SDnetDecoderBlock(params, se_block_type=None)

Standard decoder block with maxunpool -> skipconnections -> conv -> prelu -> batchnorm, without dense connections and an optional SE blocks

Parameters:
  • params (dict) –

    { ‘num_channels’:1, ‘num_filters’:64, ‘kernel_h’:5, ‘kernel_w’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}

  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

forward passed tensor
Return type:

torch.tensor [FloatTensor]
forward(input, out_block=None, indices=None, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • out_block (torch.tensor [FloatTensor], optional) – Tensor for skip connection, shape = (N x C x H x W), defaults to None
  • indices (torch.tensor, optional) – Indices used for unpooling operation, defaults to None
  • weights (torch.tensor, optional) – Weights used for squeeze and excitation, shape depends on the type of SE block, defaults to None
Returns:

Forward pass
Return type:

torch.tensor
class modules.SDnetEncoderBlock(params, se_block_type=None)

A standard conv -> prelu -> batchnorm-> maxpool block without dense connections

Parameters:
  • params (dict) –

    { ‘num_channels’:1, ‘num_filters’:64, ‘kernel_h’:5, ‘kernel_w’:5, ‘stride_conv’:1, ‘pool’:2, ‘stride_pool’:2, ‘num_classes’:28, ‘se_block’: se.SELayer.None, ‘drop_out’:0,2}

  • se_block_type (str, valid options are {'NONE', 'CSE', 'SSE', 'CSSE'}, optional) – Squeeze and Excite block type to be included, defaults to None
Returns:

output tensor with maxpool, output tensor without maxpool, indices for unpooling
Return type:

torch.tensor [FloatTensor], torch.tensor [FloatTensor], torch.tensor [LongTensor]
forward(input, weights=None)

Forward pass

Parameters:
  • input (torch.tensor [FloatTensor]) – Input tensor, shape = (N x C x H x W)
  • weights (torch.tensor, optional) – Weights used for squeeze and excitation, shape depends on the type of SE block, defaults to None
Returns:

output tensor with maxpool, output tensor without maxpool, indices for unpooling
Return type:

torch.tensor [FloatTensor], torch.tensor [FloatTensor], torch.tensor [LongTensor]