code: def __init__(
      self,
      feature_scale=4,
      n_classes=1,
      is_deconv=True,
      norm=nn.InstanceNorm2d,
      is_pool=True,
  ):
      super(UnetGCN, self).__init__()
      filters = [64, 128, 256, 512, 1024]
      filters = [x // feature_scale for x in filters]
  
      # downsampling
      self.conv1 = UnetConv2D(1, filters[0], norm)
      self.gcn1 = GCN(filters[0], filters[0])
      self.maxpool1 = (
          nn.MaxPool2d(kernel_size=2)
          if is_pool
          else ConvBNReLU(filters[0], filters[0], norm, stride=2)
      )
  
      self.conv2 = UnetConv2D(filters[0], filters[1], norm)
      self.gcn2 = GCN(filters[1], filters[1])
      self.maxpool2 = (
          nn.MaxPool2d(kernel_size=2)
          if is_pool
          else ConvBNReLU(filters[1], filters[1], norm, stride=2)
      )
  
      self.conv3 = UnetConv2D(filters[1], filters[2], norm)
      self.gcn3 = GCN(filters[2], filters[2])
      self.maxpool3 = (
          nn.MaxPool2d(kernel_size=2)
          if is_pool
          else ConvBNReLU(filters[2], filters[2], norm, stride=2)
      )
  
      self.conv4 = UnetConv2D(filters[2], filters[3], norm)
      self.gcn4 = GCN(filters[3], filters[3])
      self.maxpool4 = (
          nn.MaxPool2d(kernel_size=2)
          if is_pool
          else ConvBNReLU(filters[3], filters[3], norm, stride=2)
      )
  
      self.center = UnetConv2D(filters[3], filters[4], norm)
  
      # upsampling
      self.up_concat4 = UnetUpConv2D(
          filters[4], filters[3], norm, is_deconv
      )
      self.up_concat3 = UnetUpConv2D(
          filters[3], filters[2], norm, is_deconv
      )
      self.up_concat2 = UnetUpConv2D(
          filters[2], filters[1], norm, is_deconv
      )
      self.up_concat1 = UnetUpConv2D(
          filters[1], filters[0], norm, is_deconv
      )
  
      # final conv (without any concat)
      self.final = nn.Conv2d(filters[0], n_classes, 1)
  
      # initialise weights
      for m in self.modules():
          if isinstance(m, nn.Conv2d):
              m.apply(weights_init_kaiming)
          elif isinstance(m, nn.BatchNorm2d):
              m.apply(weights_init_kaiming)
  
imports: import torch
  import torch.nn
  import torch.nn.functional
  from .unet_layer import UnetConv2D, UnetUpConv2D, weights_init_kaiming, ConvBNReLU
  from .ExFuseLayer import SEB, GCN, ECRE, DAP, UnetExFuseLevel
label_desc: Use image node_id 1 to create a new UnetGCN object from inherited base classes: nn with example: obj = UnetGCN(feature_scale, n_classes, is_deconv, norm, is_pool)