code: import torch.nn as nn
  
  __author__ = "Sachin Mehta"
  __version__ = "1.0.1"
  __maintainer__ = "Sachin Mehta"
  
  class CBR(nn.Module):
      '''
      This class defines the convolution layer with batch normalization and PReLU activation
      '''
  
      def __init__(self, nIn, nOut, kSize, stride=1, groups=1):
          '''
  
          :param nIn: number of input channels
          :param nOut: number of output channels
          :param kSize: kernel size
          :param stride: stride rate for down-sampling. Default is 1
          '''
          super().__init__()
          padding = int((kSize - 1) / 2)
          self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False, groups=groups)
          self.bn = nn.BatchNorm2d(nOut)
          self.act = nn.PReLU(nOut)
  
      def forward(self, input):
          '''
          :param input: input feature map
          :return: transformed feature map
          '''
          output = self.conv(input)
          # output = self.conv1(output)
          output = self.bn(output)
          output = self.act(output)
          return output
  
  
  class BR(nn.Module):
      '''
          This class groups the batch normalization and PReLU activation
      '''
  
      def __init__(self, nOut):
          '''
          :param nOut: output feature maps
          '''
          super().__init__()
          self.bn = nn.BatchNorm2d(nOut)
          self.act = nn.PReLU(nOut)
  
      def forward(self, input):
          '''
          :param input: input feature map
          :return: normalized and thresholded feature map
          '''
          output = self.bn(input)
          output = self.act(output)
          return output
  
  
  class CB(nn.Module):
      '''
         This class groups the convolution and batch normalization
      '''
  
      def __init__(self, nIn, nOut, kSize, stride=1, groups=1):
          '''
          :param nIn: number of input channels
          :param nOut: number of output channels
          :param kSize: kernel size
          :param stride: optinal stide for down-sampling
          '''
          super().__init__()
          padding = int((kSize - 1) / 2)
          self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False,
                                groups=groups)
          self.bn = nn.BatchNorm2d(nOut)
  
      def forward(self, input):
          '''
  
          :param input: input feature map
          :return: transformed feature map
          '''
          output = self.conv(input)
          output = self.bn(output)
          return output
  
  
  class C(nn.Module):
      '''
      This class is for a convolutional layer.
      '''
  
      def __init__(self, nIn, nOut, kSize, stride=1, groups=1):
          '''
  
          :param nIn: number of input channels
          :param nOut: number of output channels
          :param kSize: kernel size
          :param stride: optional stride rate for down-sampling
          '''
          super().__init__()
          padding = int((kSize - 1) / 2)
          self.conv = nn.Conv2d(nIn, nOut, kSize, stride=stride, padding=padding, bias=False,
                                groups=groups)
  
      def forward(self, input):
          '''
          :param input: input feature map
          :return: transformed feature map
          '''
          output = self.conv(input)
          return output
  
  
  class CDilated(nn.Module):
      '''
      This class defines the dilated convolution.
      '''
  
      def __init__(self, nIn, nOut, kSize, stride=1, d=1, groups=1):
          '''
          :param nIn: number of input channels
          :param nOut: number of output channels
          :param kSize: kernel size
          :param stride: optional stride rate for down-sampling
          :param d: optional dilation rate
          '''
          super().__init__()
          padding = int((kSize - 1) / 2) * d
          self.conv = nn.Conv2d(nIn, nOut,kSize, stride=stride, padding=padding, bias=False,
                                dilation=d, groups=groups)
  
      def forward(self, input):
          '''
          :param input: input feature map
          :return: transformed feature map
          '''
          output = self.conv(input)
          return output
  
  class CDilatedB(nn.Module):
      '''
      This class defines the dilated convolution with batch normalization.
      '''
  
      def __init__(self, nIn, nOut, kSize, stride=1, d=1, groups=1):
          '''
          :param nIn: number of input channels
          :param nOut: number of output channels
          :param kSize: kernel size
          :param stride: optional stride rate for down-sampling
          :param d: optional dilation rate
          '''
          super().__init__()
          padding = int((kSize - 1) / 2) * d
          self.conv = nn.Conv2d(nIn, nOut,kSize, stride=stride, padding=padding, bias=False,
                                dilation=d, groups=groups)
          self.bn = nn.BatchNorm2d(nOut)
  
      def forward(self, input):
          '''
          :param input: input feature map
          :return: transformed feature map
          '''
          return self.bn(self.conv(input))
  
apis: torch.nn.PReLU torch.nn.BatchNorm2d torch.nn.Conv2d