class_docstr: This class is used to automatically find problematic nodes in a model. It takes a FX
  graphmodule and generate some submodules while traverse the graph. Then two functions
  `run_a` and `run_b` will be used to run the same submodule and a function `compare_fn`
  will be used to compare the results.
  
  Currently we provides two ways to traverse the graph and generate submodules.
      1. Sequential traversal: this will traverse the graph node by node and generate
         one submodule with one sigle node.
      2. Binary searching: this will do a binary search style traversal on the graph.
  
  For internal Users, a guide can be found here https://fb.quip.com/HDtuAgiKGfkP.
code: def _accumulate_traverse(self, nodes: NodeList) -> NodeSet:
      culprits: NodeSet = set()
      nodes_to_run: NodeSet = set()
  
      # find_all is not supported for accumulate traversal because all the
      # ops run on NNPI. So we return after the first op that raises error.
      if self.settings.find_all:
          print(
              "'Find All' mode is not supported in accumulate traversal."
          )
          return culprits
  
      for node in nodes:
          report: List[str] = []
          self.reports.append(report)
          self.iteration += 1
          report.append(
              f"Accumulate traverse iteration {self.iteration}."
          )
  
          nodes_to_run.add(node)
  
          node_name = node.name
          if node_name is not None and isinstance(node_name, tuple):
              node_name = node_name[0]
          assert node_name is not None and isinstance(
              node_name, str
          ), f"minimize: node_name: {node_name}"
  
          report.append(f"Add node: {node_name}")
  
          try:
              split_module, submod_name = self._build_submodule(
                  nodes_to_run
              )
              self._run_and_compare(
                  split_module, submod_name, [node_name]
              )
              self.print_report(report)
          except (
              FxNetMinimizerResultMismatchError,
              FxNetMinimizerRunFuncError,
          ):
              culprits.add(node)
              report.append(f"Found culprit {node}")
              self.print_report(report)
              return culprits
  
      return culprits
  
imports: import logging
  from dataclasses import dataclass
  from typing import Any, Callable, Dict, List, Optional, Tuple
  import torch
  import torch.fx
  from torch.fx._compatibility import compatibility
  from torch.fx.node import map_arg
  from .shape_prop import ShapeProp
  from .split_utils import split_by_tags
  from .tools_common import CALLABLE_NODE_OPS, FxNetAccFusionsFinder, Names, NodeList, NodeSet, TensorOrTensors, Tensors
label_desc: Use image node_id 12 for calling the _MinimizerBase obj's underlying member method code with example usage: obj._accumulate_traverse(nodes) and returns: culprits, culprits, culprits