class_docstr: Layer-wise relevance propagation is based on a backward propagation
  mechanism applied sequentially to all layers of the model. Here, the
  model output score represents the initial relevance which is decomposed
  into values for each neuron of the underlying layers. The decomposition
  is defined by rules that are chosen for each layer, involving its weights
  and activations. Details on the model can be found in the original paper
  [https://doi.org/10.1371/journal.pone.0130140]. The implementation is
  inspired by the tutorial of the same group
  [https://doi.org/10.1016/j.dsp.2017.10.011] and the publication by
  Ancona et al. [https://openreview.net/forum?id=Sy21R9JAW].
docstr: Here, we use the completeness property of LRP: The relevance is conserved
  during the propagation through the models' layers. Therefore, the difference
  between the sum of attribution (relevance) values and model output is taken as
  the convergence delta. It should be zero for functional attribution. However,
  when rules with an epsilon value are used for stability reasons, relevance is
  absorbed during propagation and the convergence delta is non-zero.
  
  Args:
  
      attributions (Tensor or tuple[Tensor, ...]): Attribution scores that
                  are precomputed by an attribution algorithm.
                  Attributions can be provided in form of a single tensor
                  or a tuple of those. It is assumed that attribution
                  tensor's dimension 0 corresponds to the number of
                  examples, and if multiple input tensors are provided,
                  the examples must be aligned appropriately.
  
      output (Tensor): The output value with respect to which
                  the attribution values are computed. This value corresponds to
                  the target score of a classification model. The given tensor
                  should only have a single element.
  
  Returns:
      *Tensor*:
      - **delta** Difference of relevance in output layer and input layer.
code: def compute_convergence_delta(
      self,
      attributions: Union[Tensor, Tuple[Tensor, ...]],
      output: Tensor,
  ) -> Tensor:
      """
      Here, we use the completeness property of LRP: The relevance is conserved
      during the propagation through the models' layers. Therefore, the difference
      between the sum of attribution (relevance) values and model output is taken as
      the convergence delta. It should be zero for functional attribution. However,
      when rules with an epsilon value are used for stability reasons, relevance is
      absorbed during propagation and the convergence delta is non-zero.
  
      Args:
  
          attributions (Tensor or tuple[Tensor, ...]): Attribution scores that
                      are precomputed by an attribution algorithm.
                      Attributions can be provided in form of a single tensor
                      or a tuple of those. It is assumed that attribution
                      tensor's dimension 0 corresponds to the number of
                      examples, and if multiple input tensors are provided,
                      the examples must be aligned appropriately.
  
          output (Tensor): The output value with respect to which
                      the attribution values are computed. This value corresponds to
                      the target score of a classification model. The given tensor
                      should only have a single element.
  
      Returns:
          *Tensor*:
          - **delta** Difference of relevance in output layer and input layer.
      """
      if isinstance(attributions, tuple):
          for attr in attributions:
              summed_attr = cast(
                  Tensor, sum(_sum_rows(attr) for attr in attributions)
              )
      else:
          summed_attr = _sum_rows(attributions)
      return output.flatten() - summed_attr.flatten()
  
imports: import typing
  from collections import defaultdict
  from typing import Any, cast, List, Tuple, Union
  import torch.nn
  from captum._utils.common import _format_output, _format_tensor_into_tuples, _is_tuple, _register_backward_hook, _run_forward
  from captum._utils.gradient import apply_gradient_requirements, undo_gradient_requirements
  from captum._utils.typing import Literal, TargetType, TensorOrTupleOfTensorsGeneric
  from captum.attr._utils.attribution import GradientAttribution
  from captum.attr._utils.common import _sum_rows
  from captum.attr._utils.custom_modules import Addition_Module
  from captum.attr._utils.lrp_rules import EpsilonRule, PropagationRule
  from captum.log import log_usage
  from torch import Tensor
  from torch.nn import Module
  from torch.utils.hooks import RemovableHandle
label_desc: Use image node_id 7 for calling the LRP obj's underlying member method code with example usage: obj.compute_convergence_delta(attributions, output) and returns: unknown