class_docstr: Convenience class for analyzers that revert the model's structure.
  
  This class contains many helper functions around the graph
  reverse function :func:`innvestigate.backend.graph.reverse_model`.
  
  The deriving classes should specify how the graph should be reverted
  by implementing the following functions:
  
  * :func:`_reverse_mapping(layer)` given a layer this function
    returns a reverse mapping for the layer as specified in
    :func:`innvestigate.backend.graph.reverse_model` or None.
  
    This function can be implemented, but it is encouraged to
    implement a default mapping and add additional changes with
    the function :func:`_add_conditional_reverse_mapping` (see below).
  
    The default behavior is finding a conditional mapping (see below),
    if none is found, :func:`_default_reverse_mapping` is applied.
  * :func:`_default_reverse_mapping` defines the default
    reverse mapping.
  * :func:`_head_mapping` defines how the outputs of the model
    should be instantiated before the are passed to the reversed
    network.
  
  Furthermore other parameters of the function
  :func:`innvestigate.backend.graph.reverse_model` can
  be changed by setting the according parameters of the
  init function:
  
  :param reverse_verbose: Print information on the reverse process.
  :param reverse_clip_values: Clip the values that are passed along
    the reverted network. Expects tuple (min, max).
  :param reverse_project_bottleneck_layers: Project the value range
    of bottleneck tensors in the reverse network into another range.
  :param reverse_check_min_max_values: Print the min/max values
    observed in each tensor along the reverse network whenever
    :func:`analyze` is called.
  :param reverse_check_finite: Check if values passed along the
    reverse network are finite.
  :param reverse_keep_tensors: Keeps the tensors created in the
    backward pass and stores them in the attribute
    :attr:`_reversed_tensors`.
  :param reverse_reapply_on_copied_layers: See
    :func:`innvestigate.backend.graph.reverse_model`.
code: def _create_analysis(
      self, model: Model, stop_analysis_at_tensors: list[Tensor] = None
  ):
      if stop_analysis_at_tensors is None:
          stop_analysis_at_tensors = []
  
      return_all_reversed_tensors = (
          self._reverse_check_min_max_values
          or self._reverse_check_finite
          or self._reverse_keep_tensors
      )
  
      # if return_all_reversed_tensors is False,
      # reversed_tensors will be None
      reversed_input_tensors, reversed_tensors = self._reverse_model(
          model,
          stop_analysis_at_tensors=stop_analysis_at_tensors,
          return_all_reversed_tensors=return_all_reversed_tensors,
      )
      ret = self._postprocess_analysis(reversed_input_tensors)
  
      if return_all_reversed_tensors:
          if reversed_tensors is None:
              raise TypeError("Expected reversed_tensors, got None.")
  
          debug_tensors: list[Tensor]
          tmp: list[Tensor]
  
          debug_tensors = []
          values = reversed_tensors.values()
          mapping = {i: v["nid"] for i, v in enumerate(values)}
          tensors = [v["final_tensor"] for v in values]
          self._reverse_tensors_mapping = mapping
  
          if self._reverse_check_min_max_values:
              tmp = [kbackend.min(x) for x in tensors]
              self._debug_tensors_indices["min"] = (
                  len(debug_tensors),
                  len(debug_tensors) + len(tmp),
              )
              debug_tensors += tmp
  
              tmp = [kbackend.min(x) for x in tensors]
              self._debug_tensors_indices["max"] = (
                  len(debug_tensors),
                  len(debug_tensors) + len(tmp),
              )
              debug_tensors += tmp
  
          if self._reverse_check_finite:
              tmp = ibackend.to_list(ilayers.FiniteCheck()(tensors))
              self._debug_tensors_indices["finite"] = (
                  len(debug_tensors),
                  len(debug_tensors) + len(tmp),
              )
              debug_tensors += tmp
  
          if self._reverse_keep_tensors:
              self._debug_tensors_indices["keep"] = (
                  len(debug_tensors),
                  len(debug_tensors) + len(tensors),
              )
              debug_tensors += tensors
  
          return ret, debug_tensors
      return ret
  
imports: from __future__ import annotations
  from typing import Callable
  import numpy
  import tensorflow.keras.backend
  import innvestigate.backend
  import innvestigate.backend.graph
  import innvestigate.layers
  from innvestigate.analyzer.network_base import AnalyzerNetworkBase
  from innvestigate.backend.types import CondReverseMapping, Layer, Model, OptionalList, ReverseTensorDict, Tensor
label_desc: Use image node_id 10 for calling the ReverseAnalyzerBase obj's underlying member method code with example usage: obj._create_analysis(model, stop_analysis_at_tensors) and returns: ret, ret,  debug_tensors