class_docstr: Convenience interface for analyzers.
  
  This class provides helpful functionality to create analyzer's.
  Basically it:
  
  * takes the input model and adds a layer that selects
    the desired output neuron to analyze.
  * passes the new model to :func:`_create_analysis` which should
    return the analysis as Keras tensors.
  * compiles the function and serves the output to :func:`analyze` calls.
  * allows :func:`_create_analysis` to return tensors
    that are intercept for debugging purposes.
  
  :param allow_lambda_layers: Allow the model to contain lambda layers.
docstr: Creates the analyze functionality. If not called beforehand
  it will be called by :func:`analyze`.
docstr_tok: ["Creates","the","analyze","functionality",".","If","not","called","beforehand","it","will","be","called","by",":","func",":","`","analyze","`","."]
code: def create_analyzer_model(self) -> None:
      """
      Creates the analyze functionality. If not called beforehand
      it will be called by :func:`analyze`.
      """
      model_inputs: list[Tensor] = self._model.inputs
      (
          model,
          analysis_inputs,
          stop_analysis_at_tensors,
      ) = self._prepare_model(self._model)
      self._analysis_inputs = analysis_inputs
      self._prepared_model = model
  
      tmp = self._create_analysis(
          model, stop_analysis_at_tensors=stop_analysis_at_tensors
      )
      if isinstance(tmp, tuple):
          if len(tmp) == 3:
              analysis_outputs, debug_outputs, constant_inputs = tmp  # type: ignore
          elif len(tmp) == 2:
              analysis_outputs, debug_outputs = tmp  # type: ignore
              constant_inputs = []
          elif len(tmp) == 1:
              analysis_outputs = tmp[0]
              constant_inputs = []
              debug_outputs = []
          else:
              raise Exception(
                  "Unexpected output from _create_analysis."
              )
      else:
          analysis_outputs = tmp
          constant_inputs = []
          debug_outputs = []
  
      analysis_outputs = ibackend.to_list(analysis_outputs)
      debug_outputs = ibackend.to_list(debug_outputs)
      constant_inputs = ibackend.to_list(constant_inputs)
  
      self._n_data_input = len(model_inputs)
      self._n_constant_input = len(constant_inputs)
      self._n_data_output = len(analysis_outputs)
      self._n_debug_output = len(debug_outputs)
  
      inputs = model_inputs + analysis_inputs + constant_inputs
      outputs = analysis_outputs + debug_outputs
  
      self._analyzer_model = kmodels.Model(
          inputs=inputs,
          outputs=outputs,
          name=f"{self.__class__.__name__}_analyzer_model",
      )
      self._analyzer_model_done = True
  
imports: from __future__ import annotations
  from typing import Any
  import numpy
  import tensorflow.keras.backend
  import tensorflow.keras.layers
  import tensorflow.keras.models
  import innvestigate.backend
  import innvestigate.backend.checks
  import innvestigate.layers
  from innvestigate.analyzer.base import AnalyzerBase
  from innvestigate.backend.types import Layer, LayerCheck, Model, OptionalList, Tensor
label_desc: Use image node_id 5 for calling the AnalyzerNetworkBase obj's underlying member method code with example usage: obj.create_analyzer_model() without return types