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 instantiate(
      self,
      hidden_dim: _typ.Optional[int] = None,
      layer_number: _typ.Optional[int] = None,
      dropout: _typ.Optional[float] = None,
      input_dim: _typ.Optional[int] = None,
      output_dim: _typ.Optional[int] = None,
      ops_type=None,
      gnn_ops: _typ.Sequence[_typ.Union[str, _typ.Any]] = None,
      act_op=None,
      head=None,
      agg_ops=None,
      # con_ops: _typ.Sequence[_typ.Union[str, _typ.Any]] = None,
  ):
      super().instantiate()
      self.dropout = dropout or self.dropout
      self.hidden_dim = hidden_dim or self.hidden_dim
      self.layer_number = layer_number or self.layer_number
      self.input_dim = input_dim or self.input_dim
      self.output_dim = output_dim or self.output_dim
      self.gnn_ops = gnn_ops or self.gnn_ops
      self.act_op = act_op or self.act_op
      self.act = act_map(self.act_op)
      self.head = head or self.head
      self.ops_type = ops_type or self.ops_type
      self.agg_ops = agg_ops or self.agg_ops
      PRIMITIVES = list(OPS[self.ops_type].keys())
      self.gnn_map = lambda x, *args, **kwargs: OPS[self.ops_type][x](
          *args, **kwargs
      )
      self.gnn_ops = self.gnn_ops or PRIMITIVES
      self.agg_map = lambda x, *args, **kwargs: agg_map[x](
          *args, **kwargs
      )
      # self.preproc0 = nn.Linear(self.input_dim, self.input_dim)
  
      for layer in range(1, self.layer_number + 1):
          # stem path
          layer_stem = f"{layer-1}->{layer}"
          key = f"stem_{layer_stem}"
          self._set_layer_choice(layer_stem, key)
  
          # input
          key = f"in_{layer}"
          # self._set_input_choice(key,layer, choose_from=node_labels, n_chosen=1, return_mask=False)
          self._set_input_choice(
              key,
              layer,
              n_candidates=layer,
              n_chosen=1,
              return_mask=False,
          )
  
          # agg
          key = f"agg_{layer}"
          self._set_agg_choice(layer, key=key)
  
      for l1 in range(1, self.layer_number + 1):
          for l2 in range(l1):
              # from l2 to l1; l2 means input layer; l1 means output layer
              layer = f"{l2}->{l1}"
              # side path
              key = f"side_{layer}"
              for i in range(2):
                  sub_key = f"{key}_{i}"
                  self._set_layer_choice(layer, sub_key)
  
      self._initialized = True
  
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 2 for calling the AutoAttendNodeClassificationSpace obj's underlying member method code with example usage: obj.instantiate(hidden_dim, layer_number, dropout, input_dim, output_dim, ops_type, gnn_ops, act_op, head, agg_ops) without return types