class_docstr: This is a computationally-inefficient implementation that computes the type of
  "infinitesimal" influence scores defined in the paper "Understanding Black-box
  Predictions via Influence Functions" by Koh et al
  (https://arxiv.org/pdf/1703.04730.pdf). The computational bottleneck in computing
  infinitesimal influence scores is computing inverse Hessian-vector products, as can
  be seen from its definition in `InfluenceFunctionBase`. This implementation is
  inefficient / naive in that it explicitly forms the Hessian :math`H`, unlike other
  implementations which compute inverse Hessian-vector products without explicitly
  forming the Hessian. The purpose of this implementation is to have a way to
  generate the "ground-truth" influence scores, to which other implementations,
  which are more efficient but return only approximations of the influence score, can
  be compared.
  
  This implementation computes a low-rank approximation of the inverse Hessian, i.e.
  a tall and skinny (with width k) matrix :math`R` such that
  :math`H^{-1} \approx RR'`, where k is small. In particular, let :math`L` be the
  matrix of width k whose columns contain the top-k eigenvectors of :math`H`, and let
  :math`V` be the k by k matrix whose diagonals contain the corresponding eigenvalues.
  This implementation lets :math`R=LV^{-1}L'`. Thus, the core computational step is
  computing the top-k eigenvalues / eigenvectors.
  
  This low-rank approximation is useful for several reasons:
  - It avoids numerical issues associated with inverting small eigenvalues.
  - Since the influence score is given by
    :math`\nabla_\theta L(x)' H^{-1} \nabla_\theta L(z)`, which is approximated by
    :math`(\nabla_\theta L(x)' R) (\nabla_\theta L(z)' R)`, we can compute an
    "influence embedding" for a given example :math`x`, :math`\nabla_\theta L(x)' R`,
    such that the influence score of one example on another is approximately the
    dot-product of their respective embeddings.
  
  This implementation is "naive" in that it computes the top-k eigenvalues /
  eigenvectors by explicitly forming the Hessian, converting it to a 2D tensor,
  computing its eigenvectors / eigenvalues, and then sorting. See documentation of the
  `_retrieve_projections_naive_influence_function` method for more details.
docstr: Computes self influence scores for the examples in `inputs_dataset`, which is
  either a single batch or a Pytorch `DataLoader` that yields batches. Therefore,
  the computed self influence scores are *not* for the examples in training
  dataset `train_dataset` (unlike when computing self influence scores using the
  `influence` method). Note that if `inputs_dataset` is a single batch, this
  will call `model` on that single batch, and if `inputs_dataset` yields
  batches, this will call `model` on each batch that is yielded. Therefore,
  please ensure that for both cases, the batch(es) that `model` is called
  with are not too large, so that there will not be an out-of-memory error.
  
  Implementation-wise, the self-influence score for an example is simply the
  squared norm of the example's "embedding" vector. Therefore, the implementation
  leverages `compute_intermediate_quantities`.
  
  Args:
      inputs_dataset (tuple or DataLoader): Either a single tuple of any, or a
              `DataLoader`, where each batch yielded is a tuple of any. In
              either case, the tuple represents a single batch, where the last
              element is assumed to be the labels for the batch. That is,
              `model(*batch[0:-1])` produces the output for `model`,
              and `batch[-1]` are the labels, if any. This is the same
              assumption made for each batch yielded by training dataset
              `train_dataset`.
              Default: None
      show_progress (bool, optional): Computation of self influence scores can
              take a long time if `inputs_dataset` represents many examples. If
              `show_progress`is true, the progress of this computation will be
              displayed. In particular, the number of batches for which
              self influence scores have been computed will be displayed. It will
              try to use tqdm if available for advanced features (e.g. time
              estimation). Otherwise, it will fallback to a simple output of
              progress.
              Default: False
docstr_tok: ["Computes","self","influence","scores","for","the","examples","in","`","inputs_dataset","`",",","which","is","either","a","single","batch","or","a","Pytorch","`","DataLoader","`","that","yields","batches",".","Therefore",",","the","computed","self","influence","scores","are","*","not","*","for","the","examples","in","training","dataset","`","train_dataset","`","(","unlike","when","computing","self","influence","scores","using","the","`","influence","`","method",")",".","Note","that","if","`","inputs_dataset","`","is","a","single","batch",",","this","will","call","`","model","`","on","that","single","batch",",","and","if","`","inputs_dataset","`","yields","batches",",","this","will","call","`","model","`","on","each","batch","that","is","yielded",".","Therefore",",","please","ensure","that","for","both","cases",",","the","batch","(","es",")","that","`","model","`","is","called","with","are","not","too","large",",","so","that","there","will","not","be","an","out-of-memory","error",".","Implementation-wise",",","the","self-influence","score","for","an","example","is","simply","the","squared","norm","of","the","example","'s","``","embedding","''","vector",".","Therefore",",","the","implementation","leverages","`","compute_intermediate_quantities","`",".","Args",":","inputs_dataset","(","tuple","or","DataLoader",")",":","Either","a","single","tuple","of","any",",","or","a","`","DataLoader","`",",","where","each","batch","yielded","is","a","tuple","of","any",".","In","either","case",",","the","tuple","represents","a","single","batch",",","where","the","last","element","is","assumed","to","be","the","labels","for","the","batch",".","That","is",",","`","model","(","*","batch","[","0",":","-1","]",")","`","produces","the","output","for","`","model","`",",","and","`","batch","[","-1","]","`","are","the","labels",",","if","any",".","This","is","the","same","assumption","made","for","each","batch","yielded","by","training","dataset","`","train_dataset","`",".","Default",":","None","show_progress","(","bool",",","optional",")",":","Computation","of","self","influence","scores","can","take","a","long","time","if","`","inputs_dataset","`","represents","many","examples",".","If","`","show_progress","`","is","true",",","the","progress","of","this","computation","will","be","displayed",".","In","particular",",","the","number","of","batches","for","which","self","influence","scores","have","been","computed","will","be","displayed",".","It","will","try","to","use","tqdm","if","available","for","advanced","features","(","e.g",".","time","estimation",")",".","Otherwise",",","it","will","fallback","to","a","simple","output","of","progress",".","Default",":","False"]
code: def self_influence(
      self,
      inputs_dataset: Optional[
          Union[Tuple[Any, ...], DataLoader]
      ] = None,
      show_progress: bool = False,
  ) -> Tensor:
      """
      Computes self influence scores for the examples in `inputs_dataset`, which is
      either a single batch or a Pytorch `DataLoader` that yields batches. Therefore,
      the computed self influence scores are *not* for the examples in training
      dataset `train_dataset` (unlike when computing self influence scores using the
      `influence` method). Note that if `inputs_dataset` is a single batch, this
      will call `model` on that single batch, and if `inputs_dataset` yields
      batches, this will call `model` on each batch that is yielded. Therefore,
      please ensure that for both cases, the batch(es) that `model` is called
      with are not too large, so that there will not be an out-of-memory error.
  
      Implementation-wise, the self-influence score for an example is simply the
      squared norm of the example's "embedding" vector. Therefore, the implementation
      leverages `compute_intermediate_quantities`.
  
      Args:
          inputs_dataset (tuple or DataLoader): Either a single tuple of any, or a
                  `DataLoader`, where each batch yielded is a tuple of any. In
                  either case, the tuple represents a single batch, where the last
                  element is assumed to be the labels for the batch. That is,
                  `model(*batch[0:-1])` produces the output for `model`,
                  and `batch[-1]` are the labels, if any. This is the same
                  assumption made for each batch yielded by training dataset
                  `train_dataset`.
                  Default: None
          show_progress (bool, optional): Computation of self influence scores can
                  take a long time if `inputs_dataset` represents many examples. If
                  `show_progress`is true, the progress of this computation will be
                  displayed. In particular, the number of batches for which
                  self influence scores have been computed will be displayed. It will
                  try to use tqdm if available for advanced features (e.g. time
                  estimation). Otherwise, it will fallback to a simple output of
                  progress.
                  Default: False
      """
      return _self_influence_helper_intermediate_quantities_influence_function(
          self, inputs_dataset, show_progress
      )
  
imports: import functools
  from abc import abstractmethod
  from operator import add
  from typing import Any, Callable, List, Optional, Tuple, Union
  import torch
  import torch.nn
  from captum._utils.gradient import _extract_parameters_from_layers
  from captum.influence._core.influence import DataInfluence
  from captum.influence._utils.common import _check_loss_fn, _compute_batch_loss_influence_function_base, _compute_jacobian_sample_wise_grads_per_batch, _dataset_fn, _flatten_params, _format_inputs_dataset, _functional_call, _get_k_most_influential_helper, _influence_batch_intermediate_quantities_influence_function, _influence_helper_intermediate_quantities_influence_function, _influence_route_to_helpers, _load_flexible_state_dict, _params_to_names, _progress_bar_constructor, _self_influence_helper_intermediate_quantities_influence_function, _set_active_parameters, _top_eigen, _unflatten_params_factory, KMostInfluentialResults
  from captum.log import log_usage
  from torch import Tensor
  from torch.nn import Module
  from torch.utils.data import DataLoader, Dataset
  from tqdm import tqdm
label_desc: Use image node_id 7 for calling the NaiveInfluenceFunction obj's underlying member method code with example usage: obj.self_influence(inputs_dataset, show_progress) and returns: _self_influence_helper_intermediate_quantities_influence_function