class_docstr: single DenseNet block as used in iNeuBe model.
  
  Args:
      in_channels: number of input channels (image axis).
      out_channels: number of output channels (image axis).
      num_freqs: number of complex frequencies in the
          input STFT complex image-like tensor.
          The input is batch, image_channels, frames, freqs.
      pre_blocks: dense block before point-wise convolution block over frequency axis.
      freq_proc_blocks: number of frequency axis processing blocks.
      post_blocks: dense block after point-wise convolution block over frequency axis.
      ksz: kernel size used in densenet Conv2D layers.
      activation: activation function to use in the whole iNeuBe model,
              you can use any torch supported activation e.g. 'relu' or 'elu'.
      hid_chans: number of hidden channels in densenet Conv2D.
code: def __init__(
      self,
      in_channels,
      out_channels,
      num_freqs,
      pre_blocks=2,
      freq_proc_blocks=1,
      post_blocks=2,
      ksz=(3, 3),
      activation=torch.nn.ELU,
      hid_chans=32,
  ):
      super(DenseBlock, self).__init__()
  
      assert post_blocks >= 1
      assert pre_blocks >= 1
  
      self.pre_blocks = torch.nn.ModuleList([])
      tot_layers = 0
      for indx in range(pre_blocks):
          c_layer = Conv2DActNorm(
              in_channels + hid_chans * tot_layers,
              hid_chans,
              ksz,
              (1, 1),
              (1, 1),
              activation=activation,
          )
          self.pre_blocks.append(c_layer)
          tot_layers += 1
  
      self.freq_proc_blocks = torch.nn.ModuleList([])
      for indx in range(freq_proc_blocks):
          c_layer = FreqWiseBlock(
              in_channels + hid_chans * tot_layers,
              num_freqs,
              hid_chans,
              activation=activation,
          )
          self.freq_proc_blocks.append(c_layer)
          tot_layers += 1
  
      self.post_blocks = torch.nn.ModuleList([])
      for indx in range(post_blocks - 1):
          c_layer = Conv2DActNorm(
              in_channels + hid_chans * tot_layers,
              hid_chans,
              ksz,
              (1, 1),
              (1, 1),
              activation=activation,
          )
          self.post_blocks.append(c_layer)
          tot_layers += 1
  
      last = Conv2DActNorm(
          in_channels + hid_chans * tot_layers,
          out_channels,
          ksz,
          (1, 1),
          (1, 1),
          activation=activation,
      )
      self.post_blocks.append(last)
  
imports: import torch
  from packaging.version import parse
  from torch_complex.tensor import ComplexTensor
  from espnet2.torch_utils.get_layer_from_string import get_layer
label_desc: Use image node_id 1 to create a new DenseBlock object from inherited base classes: torch.nn with example: obj = DenseBlock(in_channels, out_channels, num_freqs, pre_blocks, freq_proc_blocks, post_blocks, ksz, activation, hid_chans)