code: def _extract_weights_impl(
      model_name_a: str,
      gm_a: GraphModule,
      model_name_b: str,
      gm_b: GraphModule,
      base_name_to_sets_of_related_ops: Optional[
          Dict[str, Set[NSNodeTargetType]]
      ] = None,
      unmatchable_types_map: Optional[
          Dict[str, Set[NSNodeTargetType]]
      ] = None,
      op_to_type_to_weight_extraction_fn: Optional[
          Dict[str, Dict[Callable, Callable]]
      ] = None,
  ) -> NSResultsType:
      torch._C._log_api_usage_once(
          "quantization_api._numeric_suite_fx._extract_weights_impl"
      )
      matched_subgraph_pairs = get_matching_subgraph_pairs(
          gm_a,
          gm_b,
          base_name_to_sets_of_related_ops,
          unmatchable_types_map,
      )
  
      # split the subgraph pairs into one data structure for each model
      nodes_and_names_to_instrument_a: List[Tuple[Node, str]] = []
      nodes_and_names_to_instrument_b: List[Tuple[Node, str]] = []
      for match_name, match in matched_subgraph_pairs.items():
          subgraph_a, subgraph_b = match
          nodes_and_names_to_instrument_a.append(
              (subgraph_a.base_op_node, match_name)
          )
          nodes_and_names_to_instrument_b.append(
              (subgraph_b.base_op_node, match_name)
          )
  
      # populate the results, one model at a time
      results: NSResultsType = {}
      _extract_weights_one_model(
          model_name_a,
          gm_a,
          nodes_and_names_to_instrument_a,
          results,
          op_to_type_to_weight_extraction_fn,
      )
      _extract_weights_one_model(
          model_name_b,
          gm_b,
          nodes_and_names_to_instrument_b,
          results,
          op_to_type_to_weight_extraction_fn,
      )
  
      # fill in missing fqn entries
      maybe_add_missing_fqns(results)
  
      # rekey on names of nodes in gm_b
      results = rekey_logger_info_on_node_name_of_model(
          results, model_name_b
      )
  
      return results
  
imports: import collections
  import torch
  import torch.nn
  import torch.ao.quantization.quantize_fx
  from torch.fx import GraphModule
  from torch.fx.graph import Node
  from torch.ao.ns.fx.mappings import get_base_name_to_sets_of_related_ops
  from torch.ao.ns.fx.graph_matcher import get_matching_subgraph_pairs, get_type_a_related_to_b
  from .fx.weight_utils import extract_weight_from_node
  from .fx.graph_passes import add_loggers_to_model, create_a_shadows_b
  from .fx.utils import rekey_logger_info_on_node_name_of_model, maybe_add_missing_fqns, get_target_type_str
  from .fx.ns_types import NSSingleResultValuesType, NSResultsType, NSNodeTargetType
  from torch.ao.quantization.backend_config.utils import get_fusion_pattern_to_root_node_getter
  from torch.ao.quantization.backend_config import BackendConfig
  from torch.ao.quantization.fx.match_utils import _find_matches
  from torch.ao.quantization.fx.graph_module import _get_observed_graph_module_attr
  from torch.ao.quantization.fx.qconfig_mapping_utils import _generate_node_name_to_qconfig
  from torch.ao.quantization.fx.quantize_handler import _get_pattern_to_quantize_handlers
  from torch.ao.quantization.qconfig import QConfigAny
  from torch.ao.quantization import QConfigMapping
  from torch.ao.ns.fx.n_shadows_utils import OutputProp, _get_dedup_subgraphs, SHADOW_WRAPPER_NODE_NAME_PREFIX, group_results_by_subgraph, create_results_comparison, print_n_shadows_summary, create_n_transformed_and_logged_copies_of_subgraph, create_add_loggers_graph, extract_weight_comparison
  from torch.ao.ns.fx.qconfig_multi_mapping import QConfigMultiMapping
  from typing import Dict, Tuple, Callable, List, Optional, Set, Any, Type
label_desc: Use image node_id 2 for calling a global function with example usage: _extract_weights_impl(model_name_a, gm_a, model_name_b, gm_b, base_name_to_sets_of_related_ops, unmatchable_types_map, op_to_type_to_weight_extraction_fn) and returns: results