class_docstr: *Dual-path recurrent neural networks (DPRNN)* :cite:`luo2020dual`.
  
  Args:
      feat_dim (int, optional): The feature dimension after Encoder module. (Default: 64)
      hidden_dim (int, optional): Hidden dimension in the RNN layer of DPRNN. (Default: 128)
      num_blocks (int, optional): Number of DPRNN layers. (Default: 6)
      rnn_type (str, optional): Type of RNN in DPRNN. Valid options are ["RNN", "LSTM", "GRU"]. (Default: "LSTM")
      d_model (int, optional): The number of expected features in the input. (Default: 256)
      chunk_size (int, optional): Chunk size of input for DPRNN. (Default: 100)
      chunk_stride (int, optional): Stride of chunk input for DPRNN. (Default: 50)
code: def __init__(
      self,
      feat_dim: int = 64,
      hidden_dim: int = 128,
      num_blocks: int = 6,
      rnn_type: str = "LSTM",
      d_model: int = 256,
      chunk_size: int = 100,
      chunk_stride: int = 50,
  ) -> None:
      super(DPRNN, self).__init__()
  
      self.num_blocks = num_blocks
  
      self.row_rnn = nn.ModuleList([])
      self.col_rnn = nn.ModuleList([])
      self.row_norm = nn.ModuleList([])
      self.col_norm = nn.ModuleList([])
      for _ in range(num_blocks):
          self.row_rnn.append(SingleRNN(rnn_type, feat_dim, hidden_dim))
          self.col_rnn.append(SingleRNN(rnn_type, feat_dim, hidden_dim))
          self.row_norm.append(nn.GroupNorm(1, feat_dim, eps=1e-8))
          self.col_norm.append(nn.GroupNorm(1, feat_dim, eps=1e-8))
      self.conv = nn.Sequential(
          nn.Conv2d(feat_dim, d_model, 1),
          nn.PReLU(),
      )
      self.chunk_size = chunk_size
      self.chunk_stride = chunk_stride
  
imports: import math
  from typing import List, Optional, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
label_desc: Use image node_id 1 to create a new DPRNN object from inherited base classes: nn with example: obj = DPRNN(feat_dim, hidden_dim, num_blocks, rnn_type, d_model, chunk_size, chunk_stride)