class_docstr: AutoAttend Search Space , please refer to http://proceedings.mlr.press/v139/guan21a.html for details.
  The current implementation is nc (no context weight sharing), 
  we will in future add other types of partial weight sharing proposed in the paper.
  
  Parameters
  ----------
  ops_type : int 
      0 or 1 , choosing from two sets of ops with index ops_type
  gnn_ops : list of str
      op names for searching, which descripts the compostion of operation pool
  act_op : str
      determine used activation function 
  agg_ops : list of str
      agg op names for searching. Only ['add','attn'] are options, as mentioned in the paper.
code: def forward(self, data):
      x = bk_feat(data)
  
      def drop(x):
          x = F.dropout(x, p=self.dropout, training=self.training)
          return x
  
      # prev_ = self.preproc0(x)
      prev_ = x
  
      side_outs = {}  # {l:[side1,side2...]} collects lth layer's input
      stem_outs = []
      input = prev_
      for layer in range(1, self.layer_number + 1):
          # do layer choice for stem
          layer_stem = f"{layer-1}->{layer}"
          op = getattr(self, f"stem_{layer_stem}")
          stem_out = bk_gconv(op, data, drop(input))
          stem_out = self.act(stem_out)
          stem_outs.append(stem_out)
  
          # do double layer choice for sides
          for l2 in range(layer, self.layer_number + 1):
              l1 = layer - 1
              layer_side = f"{l1}->{l2}"
  
              side_out_list = []
              for i in range(2):
                  op = getattr(self, f"side_{layer_side}_{i}")
                  side_out = bk_gconv(op, data, drop(input))
                  side_out = self.act(
                      side_out
                  )  # torch.Size([2, 2708, 64])
                  side_out_list.append(side_out)
              side_out = torch.stack(side_out_list, dim=0)
  
              if l2 not in side_outs:
                  side_outs[l2] = []
              side_outs[l2].append(side_out)
  
          # select input [x1,x2,x3] from side1,side2,stem
          current_side_outs = side_outs[layer]
          side_selected = getattr(self, f"in_{layer}")(
              current_side_outs
          )
          input = [stem_outs[-1], side_selected]
  
          # do agg in [add , attn]
          agg = getattr(self, f"agg_{layer}")
          input = bk_gconv(agg, data, input)
  
      # x = self.classifier2(input)
      x = input
      return F.log_softmax(x, dim=1)
  
imports: from nni.nas.pytorch.mutables import Mutable
  import typing
  import torch
  import torch.nn.functional
  from nni.nas.pytorch import mutables
  from .None import register_nas_space
  from .base import BaseSpace
  from ..utils import count_parameters, measure_latency
  from torch import nn
  from .operation import act_map, gnn_map
  from ..backend import *
  from .autoattend_space.ops1 import OPS
  from .autoattend_space.ops2 import OPS
  from .autoattend_space.operations import agg_map
label_desc: Use image node_id 6 for calling the AutoAttendNodeClassificationSpace obj's underlying member method code with example usage: obj.forward(data) and returns: F, x