class_docstr: Decoder part of the discriminator network.
  
  Args:
      base_width (int): Base dimensionality of the layers of the autoencoder.
      out_channels (int): Number of output channels.
class_docstr_tok: ["Decoder","part","of","the","discriminator","network",".","Args",":","base_width","(","int",")",":","Base","dimensionality","of","the","layers","of","the","autoencoder",".","out_channels","(","int",")",":","Number","of","output","channels","."]
code: def __init__(self, base_width: int, out_channels: int = 1) -> None:
      super().__init__()
  
      self.up_b = nn.Sequential(
          nn.Upsample(
              scale_factor=2, mode="bilinear", align_corners=True
          ),
          nn.Conv2d(
              base_width * 8, base_width * 8, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 8),
          nn.ReLU(inplace=True),
      )
      self.db_b = nn.Sequential(
          nn.Conv2d(
              base_width * (8 + 8),
              base_width * 8,
              kernel_size=3,
              padding=1,
          ),
          nn.BatchNorm2d(base_width * 8),
          nn.ReLU(inplace=True),
          nn.Conv2d(
              base_width * 8, base_width * 8, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 8),
          nn.ReLU(inplace=True),
      )
  
      self.up1 = nn.Sequential(
          nn.Upsample(
              scale_factor=2, mode="bilinear", align_corners=True
          ),
          nn.Conv2d(
              base_width * 8, base_width * 4, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 4),
          nn.ReLU(inplace=True),
      )
      self.db1 = nn.Sequential(
          nn.Conv2d(
              base_width * (4 + 8),
              base_width * 4,
              kernel_size=3,
              padding=1,
          ),
          nn.BatchNorm2d(base_width * 4),
          nn.ReLU(inplace=True),
          nn.Conv2d(
              base_width * 4, base_width * 4, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 4),
          nn.ReLU(inplace=True),
      )
  
      self.up2 = nn.Sequential(
          nn.Upsample(
              scale_factor=2, mode="bilinear", align_corners=True
          ),
          nn.Conv2d(
              base_width * 4, base_width * 2, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 2),
          nn.ReLU(inplace=True),
      )
      self.db2 = nn.Sequential(
          nn.Conv2d(
              base_width * (2 + 4),
              base_width * 2,
              kernel_size=3,
              padding=1,
          ),
          nn.BatchNorm2d(base_width * 2),
          nn.ReLU(inplace=True),
          nn.Conv2d(
              base_width * 2, base_width * 2, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width * 2),
          nn.ReLU(inplace=True),
      )
  
      self.up3 = nn.Sequential(
          nn.Upsample(
              scale_factor=2, mode="bilinear", align_corners=True
          ),
          nn.Conv2d(
              base_width * 2, base_width, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
      )
      self.db3 = nn.Sequential(
          nn.Conv2d(
              base_width * (2 + 1), base_width, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
          nn.Conv2d(base_width, base_width, kernel_size=3, padding=1),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
      )
  
      self.up4 = nn.Sequential(
          nn.Upsample(
              scale_factor=2, mode="bilinear", align_corners=True
          ),
          nn.Conv2d(base_width, base_width, kernel_size=3, padding=1),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
      )
      self.db4 = nn.Sequential(
          nn.Conv2d(
              base_width * 2, base_width, kernel_size=3, padding=1
          ),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
          nn.Conv2d(base_width, base_width, kernel_size=3, padding=1),
          nn.BatchNorm2d(base_width),
          nn.ReLU(inplace=True),
      )
  
      self.fin_out = nn.Sequential(
          nn.Conv2d(base_width, out_channels, kernel_size=3, padding=1)
      )
  
imports: from __future__ import annotations
  import torch
  from torch import Tensor, nn
  from anomalib.models.components.layers import SSPCAB
label_desc: Use image node_id 1 to create a new DecoderDiscriminative object from inherited base classes: nn with example: obj = DecoderDiscriminative(base_width, out_channels)