class_docstr: Causal CNN, composed of a sequence of causal convolution blocks.
  Takes as input a three-dimensional tensor (`B`, `C`, `L`) where `B` is the
  batch size, `C` is the number of input channels, and `L` is the length of
  the input. Outputs a three-dimensional tensor (`B`, `C_out`, `L`).
  Parameters
  ----------
  in_channels : Number of input channels.
  channels : Number of channels processed inside the network and of output
         channels.
  depth : Depth of the network.
  out_channels : Number of output channels.
  kernel_size : Kernel size of the applied non-residual convolutions.
code: def __init__(
      self,
      in_channels: int,
      channels: int,
      depth: int,
      out_channels: int,
      kernel_size: int,
  ):
      super(CausalCNN, self).__init__()
  
      layers = []  # List of causal convolution blocks
      dilation_size = 1  # Initial dilation size
  
      for i in range(depth):
          in_channels_block = in_channels if i == 0 else channels
          layers += [
              CausalConvolutionBlock(
                  in_channels_block,
                  channels,
                  kernel_size,
                  dilation_size,
              )
          ]
          dilation_size *= 2  # Doubles the dilation size at each step
  
      # Last layer
      layers += [
          CausalConvolutionBlock(
              channels, out_channels, kernel_size, dilation_size
          )
      ]
  
      self.network = torch.nn.Sequential(*layers)
  
imports: import torch
  import torch.nn.functional
label_desc: Use image node_id 1 to create a new CausalCNN object from inherited base classes: torch.nn with example: obj = CausalCNN(in_channels, channels, depth, out_channels, kernel_size)