class_docstr: `MonitorMode` is a debug mode to easily step through function execution.
  
  Its default behavior is to behave like the 'FAST_RUN' mode. By providing
  either a `pre_func` (called before a node is executed) or a `post_func`
  (called after a node is executed) monitoring function, the user can inspect
  node behavior.
  
  A typical use case is to detect the introduction of NaN values in a graph.
  For an example of such a use case, see doc/tutorial/debug_faq.txt.
  
  Parameters
  ----------
  pre_func
      A function to call before executing a thunk, with arguments:
      - the thunk index
      - the Apply node
      - the thunk to be called
  post_func
      A function to call after executing a thunk, with the same three
      arguments as `pre_func`.
  optimizer
      The optimizer to use. One may use for instance 'fast_compile' to skip
      optimizations.
  linker
      DO NOT USE. This mode uses its own linker. The parameter is needed to
      allow selecting optimizers to use.
code: def __init__(
      self,
      pre_func=None,
      post_func=None,
      optimizer="default",
      linker=None,
  ):
      self.pre_func = pre_func
      self.post_func = post_func
      wrap_linker = theano.gof.WrapLinkerMany(
          [theano.gof.OpWiseCLinker()], [self.eval]
      )
      if optimizer == "default":
          optimizer = theano.config.optimizer
      if linker is not None and not isinstance(
          linker.mode, MonitorMode
      ):
          raise Exception(
              "MonitorMode can only use its own linker! You "
              "should not provide one.",
              linker,
          )
  
      super(MonitorMode, self).__init__(
          wrap_linker, optimizer=optimizer
      )
  
file_path: Theano/theano/compile/monitormode.py
imports: from __future__ import absolute_import, print_function, division
  import numpy
  import theano
  from theano.compile.mode import Mode
label_desc: Use image node_id 1 to create a new MonitorMode object from inherited base classes: Mode with example: obj = MonitorMode(pre_func, post_func, optimizer, linker)