code: def __init__(
      self,
      num_classes=12,
      in_channels=3,
      down_blocks=(5, 5, 5, 5, 5),
      up_blocks=(5, 5, 5, 5, 5),
      bottleneck_layers=5,
      growth_rate=16,
      out_chans_first_conv=48,
      **kwargs,
  ):
      super().__init__()
      self.num_classes = num_classes
      self.down_blocks = down_blocks
      self.up_blocks = up_blocks
      cur_channels_count = 0
      skip_connection_channel_counts = []
  
      ## First Convolution ##
  
      self.add_module(
          "firstconv",
          nn.Conv2d(
              in_channels=in_channels,
              out_channels=out_chans_first_conv,
              kernel_size=3,
              stride=1,
              padding=1,
              bias=True,
          ),
      )
      cur_channels_count = out_chans_first_conv
  
      #####################
      # Downsampling path #
      #####################
  
      self.denseBlocksDown = nn.ModuleList([])
      self.transDownBlocks = nn.ModuleList([])
      for i in range(len(down_blocks)):
          self.denseBlocksDown.append(
              DenseBlock(
                  cur_channels_count, growth_rate, down_blocks[i]
              )
          )
          cur_channels_count += growth_rate * down_blocks[i]
          skip_connection_channel_counts.insert(0, cur_channels_count)
          self.transDownBlocks.append(
              TransitionDown(cur_channels_count)
          )
  
      #####################
      #     Bottleneck    #
      #####################
  
      self.add_module(
          "bottleneck",
          Bottleneck(
              cur_channels_count, growth_rate, bottleneck_layers
          ),
      )
      prev_block_channels = growth_rate * bottleneck_layers
      cur_channels_count += prev_block_channels
  
      #######################
      #   Upsampling path   #
      #######################
  
      self.transUpBlocks = nn.ModuleList([])
      self.denseBlocksUp = nn.ModuleList([])
      for i in range(len(up_blocks) - 1):
          self.transUpBlocks.append(
              TransitionUp(prev_block_channels, prev_block_channels)
          )
          cur_channels_count = (
              prev_block_channels + skip_connection_channel_counts[i]
          )
  
          self.denseBlocksUp.append(
              DenseBlock(
                  cur_channels_count,
                  growth_rate,
                  up_blocks[i],
                  upsample=True,
              )
          )
          prev_block_channels = growth_rate * up_blocks[i]
          cur_channels_count += prev_block_channels
  
      ## Final DenseBlock ##
  
      self.transUpBlocks.append(
          TransitionUp(prev_block_channels, prev_block_channels)
      )
      cur_channels_count = (
          prev_block_channels + skip_connection_channel_counts[-1]
      )
  
      self.denseBlocksUp.append(
          DenseBlock(
              cur_channels_count,
              growth_rate,
              up_blocks[-1],
              upsample=False,
          )
      )
      cur_channels_count += growth_rate * up_blocks[-1]
  
      ## Softmax ##
  
      self.finalConv = nn.Conv2d(
          in_channels=cur_channels_count,
          out_channels=num_classes,
          kernel_size=1,
          stride=1,
          padding=0,
          bias=True,
      )
  
      self.softmax = nn.LogSoftmax(dim=1)
  
imports: import torch
  import torch.nn
label_desc: Use image node_id 1 to create a new FCDenseNet object from inherited base classes: nn with example: obj = FCDenseNet(num_classes, in_channels, down_blocks, up_blocks, bottleneck_layers, growth_rate, out_chans_first_conv)