text: import torch.nn as nn
  
  
  class RODEncode(nn.Module):
  
      def __init__(self, in_channels=2):
          super(RODEncode, self).__init__()
          self.conv1a = nn.Conv3d(in_channels=in_channels, out_channels=64,
                                  kernel_size=(9, 5, 5), stride=(1, 1, 1), padding=(4, 2, 2))
          self.conv1b = nn.Conv3d(in_channels=64, out_channels=64,
                                  kernel_size=(9, 5, 5), stride=(2, 2, 2), padding=(4, 2, 2))
          self.conv2a = nn.Conv3d(in_channels=64, out_channels=128,
                                  kernel_size=(9, 5, 5), stride=(1, 1, 1), padding=(4, 2, 2))
          self.conv2b = nn.Conv3d(in_channels=128, out_channels=128,
                                  kernel_size=(9, 5, 5), stride=(2, 2, 2), padding=(4, 2, 2))
          self.conv3a = nn.Conv3d(in_channels=128, out_channels=256,
                                  kernel_size=(9, 5, 5), stride=(1, 1, 1), padding=(4, 2, 2))
          self.conv3b = nn.Conv3d(in_channels=256, out_channels=256,
                                  kernel_size=(9, 5, 5), stride=(1, 2, 2), padding=(4, 2, 2))
          self.bn1a = nn.BatchNorm3d(num_features=64)
          self.bn1b = nn.BatchNorm3d(num_features=64)
          self.bn2a = nn.BatchNorm3d(num_features=128)
          self.bn2b = nn.BatchNorm3d(num_features=128)
          self.bn3a = nn.BatchNorm3d(num_features=256)
          self.bn3b = nn.BatchNorm3d(num_features=256)
          self.relu = nn.ReLU()
  
      def forward(self, x):
          x = self.relu(self.bn1a(self.conv1a(x)))  # (B, 2, W, 128, 128) -> (B, 64, W, 128, 128)
          x = self.relu(self.bn1b(self.conv1b(x)))  # (B, 64, W, 128, 128) -> (B, 64, W/2, 64, 64)
          x = self.relu(self.bn2a(self.conv2a(x)))  # (B, 64, W/2, 64, 64) -> (B, 128, W/2, 64, 64)
          x = self.relu(self.bn2b(self.conv2b(x)))  # (B, 128, W/2, 64, 64) -> (B, 128, W/4, 32, 32)
          x = self.relu(self.bn3a(self.conv3a(x)))  # (B, 128, W/4, 32, 32) -> (B, 256, W/4, 32, 32)
          x = self.relu(self.bn3b(self.conv3b(x)))  # (B, 256, W/4, 32, 32) -> (B, 256, W/4, 16, 16)
  
          return x
  
  
  class RODDecode(nn.Module):
  
      def __init__(self, n_class):
          super(RODDecode, self).__init__()
          self.convt1 = nn.ConvTranspose3d(in_channels=256, out_channels=128,
                                           kernel_size=(4, 6, 6), stride=(2, 2, 2), padding=(1, 2, 2))
          self.convt2 = nn.ConvTranspose3d(in_channels=128, out_channels=64,
                                           kernel_size=(4, 6, 6), stride=(2, 2, 2), padding=(1, 2, 2))
          self.convt3 = nn.ConvTranspose3d(in_channels=64, out_channels=n_class,
                                           kernel_size=(3, 6, 6), stride=(1, 2, 2), padding=(1, 2, 2))
          self.prelu = nn.PReLU()
          self.sigmoid = nn.Sigmoid()
          # self.upsample = nn.Upsample(size=(rodnet_configs['win_size'], radar_configs['ramap_rsize'],
          #                                   radar_configs['ramap_asize']), mode='nearest')
  
      def forward(self, x):
          x = self.prelu(self.convt1(x))  # (B, 256, W/4, 16, 16) -> (B, 128, W/2, 32, 32)
          x = self.prelu(self.convt2(x))  # (B, 128, W/2, 32, 32) -> (B, 64, W, 64, 64)
          x = self.convt3(x)  # (B, 64, W, 64, 64) -> (B, 3, W, 128, 128)
          return x
  