code: def does_match_guidelines(
      candidate_params: dict,
      space: Space,
      template_params: dict,
      visitors=(),
      dims_to_ignore: List[tuple] = None,
  ) -> bool:
      """Check candidate compatibility with template guideline hyperparameters
  
      Parameters
      ----------
      candidate_params: Dict
          Candidate Experiment hyperparameters to be compared to `template_params` after processing
      space: Space
          Hyperparameter search space constraints for the current template
      template_params: Dict
          Template hyperparameters to which `candidate_params` will be compared after processing.
          Although the name of the function implies that these will all be guideline hyperparameters,
          this is not a requirement, as any non-guideline hyperparameters will be removed during
          processing by checking `space.names`
      visitors: Callable, or Tuple[callable] (optional)
          Extra `visit` function(s) invoked when
          :func:`~hyperparameter_hunter.utils.boltons_utils.remap`-ing both `template_params` and
          `candidate_params`. Can be used to filter out unwanted values, or to pre-process selected
          values (and more) prior to performing the final compatibility check between the processed
          `candidate_params` and guidelines in `template_params`
      dims_to_ignore: List[tuple] (optional)
          Paths to hyperparameter(s) that should be ignored when comparing `candidate_params` and
          `template_params`. By default, hyperparameters pertaining to verbosity and random states
          are ignored. Paths should be tuples of the form expected by
          :func:`~hyperparameter_hunter.utils.boltons_utils.get_path`. Additionally a path may start
          with None, which acts as a wildcard, matching any hyperparameters whose terminal path nodes
          match the value following None. For example, ``(None, "verbose")`` would match paths such as
          ``("model_init_params", "a", "verbose")`` and ``("model_extra_params", "b", 2, "verbose")``
  
      Returns
      -------
      Boolean
          True if the processed version of `candidate_params` is equal to the extracted and processed
          guidelines from `template_params`. Else, False"""
      dimensions_to_ignore = [
          (None, "verbose"),
          (None, "silent"),
          (None, "random_state"),
          (None, "seed"),
      ]
      if isinstance(dims_to_ignore, list):
          dimensions_to_ignore.extend(dims_to_ignore)
  
      # `dimensions_to_ignore` = hyperparameters to be ignored. Filter by all remaining (less
      #   dimensions in `space`, which are also ignored)
  
      def _visit(path, key, value):
          """Return False if element in space dimensions, or in dimensions being ignored. Else, return
          True. If `value` is of type tuple or set, it will be converted to a list in order to
          simplify comparisons to the JSON-formatted `candidate_params`
          """
          # Remove elements whose full paths are in `dimensions_to_ignore` or `space.names()`
          for dim in space.names() + dimensions_to_ignore:
              if (path + (key,) == dim) or (
                  dim[0] is None and dim[-1] == key
              ):
                  return False
          # Convert tuples/sets to lists
          if isinstance(value, (tuple, set)):
              return key, list(value)
          return True
  
      #################### Chain Together Visit Functions ####################
      if callable(visitors):
          visitors = (visitors,)
      visit = multi_visit(*visitors, _visit)
      # Extra `visitors` will be called first, with `_visit` acting as the default visit, called last
  
      guidelines = remap(template_params, visit=visit)
      # `guidelines` = `template_params` that are neither `space` choices, nor `dimensions_to_ignore`
      return remap(candidate_params, visit=visit) == guidelines
  
imports: from hyperparameter_hunter.feature_engineering import EngineerStep, FeatureEngineer
  from hyperparameter_hunter.i_o.exceptions import IncompatibleCandidateError
  from hyperparameter_hunter.compat.keras_helper import keras_callback_to_dict, keras_initializer_to_dict
  from hyperparameter_hunter.settings import G
  from hyperparameter_hunter.space.dimensions import Categorical, RejectedOptional
  from hyperparameter_hunter.space.space_core import Space
  from hyperparameter_hunter.utils.boltons_utils import remap, get_path
  from hyperparameter_hunter.utils.general_utils import multi_visit
  from hyperparameter_hunter.utils.optimization_utils import does_fit_in_space, get_ids_by, get_scored_params
  from copy import deepcopy
  from numbers import Number
  from pathlib import Path
  from typing import Dict, List, Tuple, Union
  import wrapt
label_desc: Use image node_id 3 for calling a global function with example usage: does_match_guidelines(candidate_params, space, template_params, visitors, dims_to_ignore) and returns: unknown, True, key,  list, False