class_docstr: Wavenet layers with weight norm and no input conditioning.
  
       |-----------------------------------------------------------------------------|
       |                                    |-> tanh    -|                           |
  res -|- conv1d(dilation) -> dropout -> + -|            * -> conv1d1x1 -> split -|- + -> res
  g -------------------------------------|  |-> sigmoid -|                        |
  o --------------------------------------------------------------------------- + --------- o
  
  Args:
      in_channels (int): number of input channels.
      hidden_channes (int): number of hidden channels.
      kernel_size (int): filter kernel size for the first conv layer.
      dilation_rate (int): dilations rate to increase dilation per layer.
          If it is 2, dilations are 1, 2, 4, 8 for the next 4 layers.
      num_layers (int): number of wavenet layers.
      c_in_channels (int): number of channels of conditioning input.
      dropout_p (float): dropout rate.
      weight_norm (bool): enable/disable weight norm for convolution layers.
code: def __init__(
      self,
      in_channels,
      hidden_channels,
      kernel_size,
      dilation_rate,
      num_layers,
      c_in_channels=0,
      dropout_p=0,
      weight_norm=True,
  ):
      super().__init__()
      assert kernel_size % 2 == 1
      assert hidden_channels % 2 == 0
      self.in_channels = in_channels
      self.hidden_channels = hidden_channels
      self.kernel_size = kernel_size
      self.dilation_rate = dilation_rate
      self.num_layers = num_layers
      self.c_in_channels = c_in_channels
      self.dropout_p = dropout_p
  
      self.in_layers = torch.nn.ModuleList()
      self.res_skip_layers = torch.nn.ModuleList()
      self.dropout = nn.Dropout(dropout_p)
  
      # init conditioning layer
      if c_in_channels > 0:
          cond_layer = torch.nn.Conv1d(
              c_in_channels, 2 * hidden_channels * num_layers, 1
          )
          self.cond_layer = torch.nn.utils.weight_norm(
              cond_layer, name="weight"
          )
      # intermediate layers
      for i in range(num_layers):
          dilation = dilation_rate**i
          padding = int((kernel_size * dilation - dilation) / 2)
          in_layer = torch.nn.Conv1d(
              hidden_channels,
              2 * hidden_channels,
              kernel_size,
              dilation=dilation,
              padding=padding,
          )
          in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
          self.in_layers.append(in_layer)
  
          if i < num_layers - 1:
              res_skip_channels = 2 * hidden_channels
          else:
              res_skip_channels = hidden_channels
  
          res_skip_layer = torch.nn.Conv1d(
              hidden_channels, res_skip_channels, 1
          )
          res_skip_layer = torch.nn.utils.weight_norm(
              res_skip_layer, name="weight"
          )
          self.res_skip_layers.append(res_skip_layer)
      # setup weight norm
      if not weight_norm:
          self.remove_weight_norm()
  
file_path: TTS/TTS/tts/layers/generic/wavenet.py
imports: import torch
  from torch import nn
label_desc: Use image node_id 1 to create a new WN object from inherited base classes: torch.nn with example: obj = WN(in_channels, hidden_channels, kernel_size, dilation_rate, num_layers, c_in_channels, dropout_p, weight_norm)