code: def __init__(
      self,
      d_model,
      d_inner,
      kernel_size,
      dropout,
      pre_lnorm=False,
      condition_types=[],
  ):
      super(PositionwiseConvFF, self).__init__()
  
      self.d_model = d_model
      self.d_inner = d_inner
      self.dropout = dropout
  
      if type(kernel_size) is not tuple:
          kernel_size = (kernel_size, kernel_size)
  
      self.CoreNet = nn.Sequential(
          nn.Conv1d(
              d_model, d_inner, kernel_size[0], 1, (kernel_size[0] // 2)
          ),
          nn.ReLU(),
          # nn.Dropout(dropout),  # worse convergence
          nn.Conv1d(
              d_inner, d_model, kernel_size[1], 1, (kernel_size[1] // 2)
          ),
          nn.Dropout(dropout),
      )
      self.layer_norm = ConditionalLayerNorm(
          d_model,
          condition_dim=d_model,
          condition_types=condition_types,
      )
      self.pre_lnorm = pre_lnorm
  
imports: from typing import Optional
  import torch
  import torch.nn
  import torch.nn.functional
  from nemo.collections.tts.modules.submodules import ConditionalInput, ConditionalLayerNorm, LinearNorm
  from nemo.collections.tts.parts.utils.helpers import get_mask_from_lengths
  from nemo.core.classes import NeuralModule, adapter_mixins, typecheck
  from nemo.core.neural_types.elements import EncodedRepresentation, LengthsType, MaskType, TokenIndex
  from nemo.core.neural_types.neural_type import NeuralType
label_desc: Use image node_id 1 to create a new PositionwiseConvFF object from inherited base classes: nn with example: obj = PositionwiseConvFF(d_model, d_inner, kernel_size, dropout, pre_lnorm, condition_types)