code: def _convert_module(
      self,
      script_module,
      module,
      module_name,
      module_python_name,
      ir_model,
  ):
      # NOTE: have not supported nested LayerChoice, i.e., a candidate module
      # also has LayerChoice or InputChoice or ValueChoice
      original_type_name = script_module.original_name
      m_attrs = None
      if original_type_name == OpTypeName.LayerChoice:
          graph = Graph(
              ir_model, -100, module_name, _internal=True
          )  # graph_id is not used now
          graph.python_name = module_python_name
          candidate_name_list = []
          for cand_name in module.names:
              cand = module[cand_name]
              script_cand = script_module._modules[str(cand_name)]
              # FIXME: should use cand_name instead of cand_full_name
              cand_full_name = build_cand_name(
                  str(cand_name), module.label
              )
              cand_python_name = build_python_name(
                  module_python_name, str(cand_name)
              )
              candidate_name_list.append(cand_full_name)
              subgraph, attrs = self._convert_module(
                  script_cand,
                  cand,
                  cand_full_name,
                  cand_python_name,
                  ir_model,
              )
              if subgraph is not None:
                  cand_node = graph.add_node(
                      subgraph.name,
                      Cell(cell_name=subgraph.name, parameters=attrs),
                  )
                  cand_node.python_name = cand_python_name
              else:
                  cand_type = "__torch__." + get_importable_name(
                      cand.__class__
                  )
                  cand_node = graph.add_node(
                      cand_full_name, cand_type, attrs
                  )
                  cand_node.python_name = cand_python_name
          graph._register()
          return graph, {
              "mutation": "layerchoice",
              "label": module.label,
              "candidates": candidate_name_list,
          }
      elif original_type_name == OpTypeName.InputChoice:
          m_attrs = self._handle_inputchoice(module)
      elif original_type_name == OpTypeName.ValueChoice:
          m_attrs = self._handle_valuechoice(module)
      elif original_type_name == OpTypeName.MutationAnchor:
          m_attrs = get_init_parameters_or_fail(module)
      elif (
          module.__class__.__module__.startswith("torch.nn")
          and original_type_name in torch.nn.__dict__
          and original_type_name not in MODULE_EXCEPT_LIST
      ):
          # this is a basic module from pytorch, no need to parse its graph
          m_attrs = get_init_parameters_or_fail(module)
      elif getattr(module, "_nni_basic_unit", False):
          # this module is marked as serialize, won't continue to parse
          m_attrs = get_init_parameters_or_fail(module)
      elif (
          isinstance(module, MutableModule)
          and not isinstance(module, Repeat)
          and module.mutables
      ):
          raise RuntimeError(
              f"Arbitrary add_mutable() is not supported in graph-based model space, but found in {module}"
          )
      if m_attrs is not None:
          return None, m_attrs
  
      # handle TorchScript graph
      sm_graph = script_module.graph
      self.global_graph_id += 1
      ir_graph = Graph(
          model=ir_model,
          graph_id=self.global_graph_id,
          name=module_name,
          _internal=True,
      )
      ir_graph.python_name = module_python_name
  
      # handle graph nodes
      self.handle_graph_nodes(
          script_module,
          sm_graph,
          module,
          module_name,
          module_python_name,
          ir_model,
          ir_graph,
      )
      self.refine_graph(ir_graph)
  
      ir_graph._register()
  
      # add mutation signal for special modules
      if original_type_name == OpTypeName.Repeat:
          attrs = {
              "mutation": "repeat",
              "label": module.label,
              "depth": module.depth_choice,
              "max_depth": module.max_depth,
              "min_depth": module.min_depth,
          }
          return ir_graph, attrs
  
      return ir_graph, {}
  
imports: import re
  import torch
  from nni.nas.space.graph import Graph, GraphModelSpace, Node, Cell, Operation
  from nni.nas.nn.pytorch import InputChoice, MutationAnchor, LayerChoice, MutableModule, Repeat
  from nni.nas.utils import get_init_parameters_or_fail, get_importable_name
  from .op_types import MODULE_EXCEPT_LIST, OpTypeName
  from .utils import _convert_name, build_full_name, _without_shape_info, _extract_info_from_trace_node, get_full_name_by_scope_name, is_layerchoice_node, match_node, build_cand_name, build_python_name
label_desc: Use image node_id 13 for calling the GraphConverter obj's underlying member method code with example usage: obj._convert_module(script_module, module, module_name, module_python_name, ir_model) and returns: ir_graph,  dict, graph,  dict, None,  m_attrs, ir_graph,  attrs