class_docstr: :param kernel_size: (int) Must be an ODD number!!
class_docstr_tok: [":","param","kernel_size",":","(","int",")","Must","be","an","ODD","number","!","!"]
code: def __init__(
      self,
      num_classes=1,
      backbone="resnet101",
      kernel_size=7,
      dap_k=3,
      **kwargs,
  ):
      super(GCNFuse, self).__init__()
      self.num_classes = num_classes
      self.resnet_features = ModelBuilder().build_encoder(
          arch=backbone, **kwargs
      )
      self.layer0 = nn.Sequential(
          self.resnet_features.conv1,
          self.resnet_features.bn1,
          self.resnet_features.relu1,
          self.resnet_features.conv3,
          self.resnet_features.bn3,
          self.resnet_features.relu3,
      )
      self.layer1 = nn.Sequential(
          self.resnet_features.maxpool, self.resnet_features.layer1
      )
      self.layer2 = self.resnet_features.layer2
      self.layer3 = self.resnet_features.layer3
      self.layer4 = self.resnet_features.layer4
  
      self.gcm1 = _GlobalConvModule(
          2048, num_classes * 4, (kernel_size, kernel_size)
      )
      self.gcm2 = _GlobalConvModule(
          1024, num_classes, (kernel_size, kernel_size)
      )
      self.gcm3 = _GlobalConvModule(
          512, num_classes * dap_k**2, (kernel_size, kernel_size)
      )
      self.gcm4 = _GlobalConvModule(
          256, num_classes * dap_k**2, (kernel_size, kernel_size)
      )
  
      self.deconv1 = nn.ConvTranspose2d(
          num_classes,
          num_classes * dap_k**2,
          kernel_size=4,
          stride=2,
          padding=1,
          bias=False,
      )
      self.deconv2 = nn.ConvTranspose2d(
          num_classes,
          num_classes * dap_k**2,
          kernel_size=4,
          stride=2,
          padding=1,
          bias=False,
      )
      self.deconv3 = nn.ConvTranspose2d(
          num_classes * dap_k**2,
          num_classes * dap_k**2,
          kernel_size=4,
          stride=2,
          padding=1,
          bias=False,
      )
      self.deconv4 = nn.ConvTranspose2d(
          num_classes * dap_k**2,
          num_classes * dap_k**2,
          kernel_size=4,
          stride=2,
          padding=1,
          bias=False,
      )
      self.deconv5 = nn.ConvTranspose2d(
          num_classes * dap_k**2,
          num_classes * dap_k**2,
          kernel_size=4,
          stride=2,
          padding=1,
          bias=False,
      )
  
      self.ecre = nn.PixelShuffle(2)
  
      self.seb1 = SEB(2048, 1024)
      self.seb2 = SEB(3072, 512)
      self.seb3 = SEB(3584, 256)
  
      self.upsample2 = nn.Upsample(scale_factor=2, mode="bilinear")
      self.upsample4 = nn.Upsample(scale_factor=4, mode="bilinear")
  
      self.DAP = nn.Sequential(
          nn.PixelShuffle(dap_k), nn.AvgPool2d((dap_k, dap_k))
      )
  
file_path: pywick/pywick/models/segmentation/testnets/lg_kernel_exfuse/large_kernel_exfuse.py
imports: import torch
  from torch import nn
  from .deeplab_resnet import ModelBuilder
  from .large_kernel import _GlobalConvModule
label_desc: Use image node_id 1 to create a new GCNFuse object from inherited base classes: nn with example: obj = GCNFuse(num_classes, backbone, kernel_size, dap_k)