class_docstr: Wide_resnet version of DeepLabV3
  mod1
  pool2
  mod2 str2
  pool3
  mod3-7
  
    structure: [3, 3, 6, 3, 1, 1]
    channels = [(128, 128), (256, 256), (512, 512), (512, 1024), (512, 1024, 2048),
                (1024, 2048, 4096)]
code: def __init__(self, num_classes, is_cuda=True, aux=False, **_):
      super(GSCNN, self).__init__()
      # self.criterion = criterion
      self.num_classes = num_classes
      self.is_cuda = is_cuda
      self.aux = aux
  
      wide_resnet = wider_resnet38_a2(classes=1, dilation=True)
  
      # wide_resnet = torch.nn.DataParallel(wide_resnet)
      # wide_resnet = wide_resnet.module
  
      self.mod1 = wide_resnet.mod1
      self.mod2 = wide_resnet.mod2
      self.mod3 = wide_resnet.mod3
      self.mod4 = wide_resnet.mod4
      self.mod5 = wide_resnet.mod5
      self.mod6 = wide_resnet.mod6
      self.mod7 = wide_resnet.mod7
      self.pool2 = wide_resnet.pool2
      self.pool3 = wide_resnet.pool3
      self.interpolate = F.interpolate
  
      self.dsn1 = nn.Conv2d(64, 1, 1)
      self.dsn3 = nn.Conv2d(256, 1, 1)
      self.dsn4 = nn.Conv2d(512, 1, 1)
      self.dsn7 = nn.Conv2d(4096, 1, 1)
  
      self.res1 = Resnet.BasicBlock(64, 64, stride=1, downsample=None)
      self.d1 = nn.Conv2d(64, 32, 1)
      self.res2 = Resnet.BasicBlock(32, 32, stride=1, downsample=None)
      self.d2 = nn.Conv2d(32, 16, 1)
      self.res3 = Resnet.BasicBlock(16, 16, stride=1, downsample=None)
      self.d3 = nn.Conv2d(16, 8, 1)
      self.fuse = nn.Conv2d(8, 1, kernel_size=1, padding=0, bias=False)
  
      self.cw = nn.Conv2d(2, 1, kernel_size=1, padding=0, bias=False)
  
      self.gate1 = gsc.GatedSpatialConv2d(32, 32)
      self.gate2 = gsc.GatedSpatialConv2d(16, 16)
      self.gate3 = gsc.GatedSpatialConv2d(8, 8)
  
      self.aspp = _AtrousSpatialPyramidPoolingModule(
          4096, 256, output_stride=8
      )
  
      self.bot_fine = nn.Conv2d(128, 48, kernel_size=1, bias=False)
      self.bot_aspp = nn.Conv2d(
          1280 + 256, 256, kernel_size=1, bias=False
      )
  
      self.final_seg = nn.Sequential(
          nn.Conv2d(
              256 + 48, 256, kernel_size=3, padding=1, bias=False
          ),
          Norm2d(256),
          nn.ReLU(inplace=True),
          nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
          Norm2d(256),
          nn.ReLU(inplace=True),
          nn.Conv2d(256, num_classes, kernel_size=1, bias=False),
      )
  
      self.sigmoid = nn.Sigmoid()
      initialize_weights(self.final_seg)
  
imports: import torch
  import torch.nn.functional
  from torch import nn
  from .None import Resnet
  from .wider_resnet import wider_resnet38_a2
  from .mynn import initialize_weights, Norm2d
  from torch.autograd import Variable
  from .my_functionals import GatedSpatialConv
  import cv2
  import numpy
label_desc: Use image node_id 1 to create a new GSCNN object from inherited base classes: nn with example: obj = GSCNN(num_classes, is_cuda, aux)