code: def __init__(
      self, num_classes, pretrained=True, k=7, input_size=512, **kwargs
  ):
      super(GCN_Resnext, self).__init__()
  
      self.num_classes = num_classes
      self.K = k
      num_imd_feats = 40
  
      self.resnext = ResNeXt(pretrained)
  
      self.gcm1 = _GlobalConvModule(
          2048, num_imd_feats, (self.K, self.K)
      )
      self.gcm2 = _GlobalConvModule(
          1024, num_imd_feats, (self.K, self.K)
      )
      self.gcm3 = _GlobalConvModule(
          512, num_imd_feats, (self.K, self.K)
      )
      self.gcm4 = _GlobalConvModule(
          256, num_imd_feats, (self.K, self.K)
      )
  
      self.brm1 = _BoundaryRefineModule(num_imd_feats)
      self.brm2 = _BoundaryRefineModule(num_imd_feats)
      self.brm3 = _BoundaryRefineModule(num_imd_feats)
      self.brm4 = _BoundaryRefineModule(num_imd_feats)
      self.brm5 = _BoundaryRefineModule(num_imd_feats)
      self.brm6 = _BoundaryRefineModule(num_imd_feats)
      self.brm7 = _BoundaryRefineModule(num_imd_feats)
      self.brm8 = _BoundaryRefineModule(num_imd_feats)
      self.brm9 = _BoundaryRefineModule(num_imd_feats)
  
      self.deconv = _DeconvModule(num_imd_feats)
  
      self.psp_module = _PyramidSpatialPoolingModule(
          num_imd_feats, 30, input_size, levels=(1, 2, 3, 6)
      )
      self.final = nn.Sequential(
          nn.Conv2d(
              num_imd_feats + self.psp_module.out_channels,
              num_imd_feats,
              kernel_size=3,
              padding=1,
          ),
          nn.BatchNorm2d(num_imd_feats),
          nn.ReLU(inplace=True),
          nn.Conv2d(
              num_imd_feats, num_classes, kernel_size=1, padding=0
          ),
      )
  
      self.initialize_weights(
          self.gcm1, self.gcm2, self.gcm3, self.gcm4
      )
      self.initialize_weights(
          self.brm1,
          self.brm2,
          self.brm3,
          self.brm4,
          self.brm5,
          self.brm6,
          self.brm7,
          self.brm8,
          self.brm9,
      )
      self.initialize_weights(self.psp_module, self.final)
  
imports: from ..None import resnext101_64x4d
  from math import floor
  import numpy
  import torch
  import torch.nn
label_desc: Use image node_id 1 to create a new GCN_Resnext object from inherited base classes: nn with example: obj = GCN_Resnext(num_classes, pretrained, k, input_size)