code: def __init__(self, option, model_type, dataset, modules):
      super(PVCNN, self).__init__()
  
      cr = option.cr
      self.vres = option.vres
      self.num_classes = dataset.num_classes
      self.num_features = dataset.feature_dimension
  
      cs = [32, 32, 64, 128, 256, 256, 128, 96, 96]
      cs = [int(cr * x) for x in cs]
  
      self.stem = nn.Sequential(
          spnn.Conv3d(
              self.num_features, cs[0], kernel_size=3, stride=1
          ),
          spnn.BatchNorm(cs[0]),
          spnn.ReLU(True),
          spnn.Conv3d(cs[0], cs[0], kernel_size=3, stride=1),
          spnn.BatchNorm(cs[0]),
          spnn.ReLU(True),
      )
  
      self.stage1 = nn.Sequential(
          BasicConvolutionBlock(
              cs[0], cs[0], ks=2, stride=2, dilation=1
          ),
          ResidualBlock(cs[0], cs[1], ks=3, stride=1, dilation=1),
          ResidualBlock(cs[1], cs[1], ks=3, stride=1, dilation=1),
      )
  
      self.stage2 = nn.Sequential(
          BasicConvolutionBlock(
              cs[1], cs[1], ks=2, stride=2, dilation=1
          ),
          ResidualBlock(cs[1], cs[2], ks=3, stride=1, dilation=1),
          ResidualBlock(cs[2], cs[2], ks=3, stride=1, dilation=1),
      )
  
      self.stage3 = nn.Sequential(
          BasicConvolutionBlock(
              cs[2], cs[2], ks=2, stride=2, dilation=1
          ),
          ResidualBlock(cs[2], cs[3], ks=3, stride=1, dilation=1),
          ResidualBlock(cs[3], cs[3], ks=3, stride=1, dilation=1),
      )
  
      self.stage4 = nn.Sequential(
          BasicConvolutionBlock(
              cs[3], cs[3], ks=2, stride=2, dilation=1
          ),
          ResidualBlock(cs[3], cs[4], ks=3, stride=1, dilation=1),
          ResidualBlock(cs[4], cs[4], ks=3, stride=1, dilation=1),
      )
  
      self.up1 = nn.ModuleList(
          [
              BasicDeconvolutionBlock(cs[4], cs[5], ks=2, stride=2),
              nn.Sequential(
                  ResidualBlock(
                      cs[5] + cs[3], cs[5], ks=3, stride=1, dilation=1
                  ),
                  ResidualBlock(
                      cs[5], cs[5], ks=3, stride=1, dilation=1
                  ),
              ),
          ]
      )
  
      self.up2 = nn.ModuleList(
          [
              BasicDeconvolutionBlock(cs[5], cs[6], ks=2, stride=2),
              nn.Sequential(
                  ResidualBlock(
                      cs[6] + cs[2], cs[6], ks=3, stride=1, dilation=1
                  ),
                  ResidualBlock(
                      cs[6], cs[6], ks=3, stride=1, dilation=1
                  ),
              ),
          ]
      )
  
      self.up3 = nn.ModuleList(
          [
              BasicDeconvolutionBlock(cs[6], cs[7], ks=2, stride=2),
              nn.Sequential(
                  ResidualBlock(
                      cs[7] + cs[1], cs[7], ks=3, stride=1, dilation=1
                  ),
                  ResidualBlock(
                      cs[7], cs[7], ks=3, stride=1, dilation=1
                  ),
              ),
          ]
      )
  
      self.up4 = nn.ModuleList(
          [
              BasicDeconvolutionBlock(cs[7], cs[8], ks=2, stride=2),
              nn.Sequential(
                  ResidualBlock(
                      cs[8] + cs[0], cs[8], ks=3, stride=1, dilation=1
                  ),
                  ResidualBlock(
                      cs[8], cs[8], ks=3, stride=1, dilation=1
                  ),
              ),
          ]
      )
  
      self.classifier = nn.Sequential(
          nn.Linear(cs[8], self.num_classes)
      )
  
      self.point_transforms = nn.ModuleList(
          [
              nn.Sequential(
                  nn.Linear(cs[0], cs[4]),
                  nn.BatchNorm1d(cs[4]),
                  nn.ReLU(True),
              ),
              nn.Sequential(
                  nn.Linear(cs[4], cs[6]),
                  nn.BatchNorm1d(cs[6]),
                  nn.ReLU(True),
              ),
              nn.Sequential(
                  nn.Linear(cs[6], cs[8]),
                  nn.BatchNorm1d(cs[8]),
                  nn.ReLU(True),
              ),
          ]
      )
  
      self.weight_initialization()
      self.dropout = nn.Dropout(0.3, True)
  
      self.loss_names = ["loss_seg"]
  
file_path: torch-points3d/torch_points3d/modules/PVCNN/pvcnn.py
imports: import torch.nn
  import torchsparse
  import torchsparse.nn
  import torchsparse.nn.functional
  from torchsparse.sparse_tensor import SparseTensor
  from torchsparse.point_tensor import PointTensor
  from torchsparse.utils.kernel_region import *
  from torchsparse.utils.helpers import *
  from torch_points3d.modules.PVCNN.blocks import *
  from torch_points3d.modules.PVCNN.utils import *
label_desc: Use image node_id 1 to create a new PVCNN object from inherited base classes: nn with example: obj = PVCNN(option, model_type, dataset, modules)