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,
      gnn_ops: _typ.Sequence[_typ.Union[str, _typ.Any]] = None,
      act_ops: _typ.Sequence[_typ.Union[str, _typ.Any]] = 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_ops = act_ops or self.act_ops
      self.con_ops = con_ops or self.con_ops
      self.preproc0 = nn.Linear(self.input_dim, self.hidden_dim)
      self.preproc1 = nn.Linear(self.input_dim, self.hidden_dim)
      node_labels = [
          mutables.InputChoice.NO_KEY,
          mutables.InputChoice.NO_KEY,
      ]
      for layer in range(2, self.layer_number + 2):
          node_labels.append(f"op_{layer}")
          setattr(
              self,
              f"in_{layer}",
              self.setInputChoice(
                  layer,
                  choose_from=node_labels[:-1],
                  n_chosen=1,
                  return_mask=False,
                  key=f"in_{layer}",
              ),
          )
          setattr(
              self,
              f"op_{layer}",
              self.setLayerChoice(
                  layer,
                  [
                      gnn_map(op, self.hidden_dim, self.hidden_dim)
                      for op in self.gnn_ops
                  ],
                  key=f"op_{layer}",
              ),
          )
      setattr(
          self,
          "act",
          self.setLayerChoice(
              2 * layer,
              [act_map_nn(a) for a in self.act_ops],
              key="act",
          ),
      )
      # for DARTS, len(con_ops) can only <=1, for dimension problems
      if len(self.con_ops) > 1:
          setattr(
              self,
              "concat",
              self.setLayerChoice(
                  2 * layer + 1, map_nn(self.con_ops), key="concat"
              ),
          )
      self._initialized = True
      self.classifier1 = nn.Linear(
          self.hidden_dim * self.layer_number, self.output_dim
      )
      self.classifier2 = nn.Linear(self.hidden_dim, self.output_dim)
  
imports: 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 ...model import BaseAutoModel
  from ..utils import count_parameters, measure_latency
  from torch import nn
  from .operation import act_map, gnn_map
  from ..backend import *
label_desc: Use image node_id 2 for calling the GraphNasNodeClassificationSpace obj's underlying member method code with example usage: obj.instantiate(hidden_dim, layer_number, dropout, input_dim, output_dim, gnn_ops, act_ops, con_ops) without return types