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.
docstr: The method that calls the thunk `fn`.
code: def eval(self, i, node, fn):
      """
      The method that calls the thunk `fn`.
  
      """
      if self.pre_func is not None:
          self.pre_func(i, node, fn)
      fn()
      if self.post_func is not None:
          self.post_func(i, node, fn)
  
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 4 for calling the MonitorMode obj's underlying member method code with example usage: obj.eval(i, node, fn) without return types