class_docstr: Lime is an interpretability method that trains an interpretable surrogate model
  by sampling points around a specified input example and using model evaluations
  at these points to train a simpler interpretable 'surrogate' model, such as a
  linear model.
  
  LimeBase provides a generic framework to train a surrogate interpretable model.
  This differs from most other attribution methods, since the method returns a
  representation of the interpretable model (e.g. coefficients of the linear model).
  For a similar interface to other perturbation-based attribution methods, please use
  the Lime child class, which defines specific transformations for the interpretable
  model.
  
  LimeBase allows sampling points in either the interpretable space or the original
  input space to train the surrogate model. The interpretable space is a feature
  vector used to train the surrogate interpretable model; this feature space is often
  of smaller dimensionality than the original feature space in order for the surrogate
  model to be more interpretable.
  
  If sampling in the interpretable space, a transformation function must be provided
  to define how a vector sampled in the interpretable space can be transformed into
  an example in the original input space. If sampling in the original input space, a
  transformation function must be provided to define how the input can be transformed
  into its interpretable vector representation.
  
  More details regarding LIME can be found in the original paper:
  https://arxiv.org/abs/1602.04938
code: def has_convergence_delta(self) -> bool:
      return False
  
imports: import inspect
  import math
  import typing
  import warnings
  from typing import Any, Callable, cast, List, Optional, Tuple, Union
  import torch
  from captum._utils.common import _expand_additional_forward_args, _expand_target, _flatten_tensor_or_tuple, _format_output, _format_tensor_into_tuples, _get_max_feature_index, _is_tuple, _reduce_list, _run_forward
  from captum._utils.models.linear_model import SkLearnLasso
  from captum._utils.models.model import Model
  from captum._utils.progress import progress
  from captum._utils.typing import BaselineType, Literal, TargetType, TensorOrTupleOfTensorsGeneric
  from captum.attr._utils.attribution import PerturbationAttribution
  from captum.attr._utils.batching import _batch_example_iterator
  from captum.attr._utils.common import _construct_default_feature_mask, _format_input_baseline
  from captum.log import log_usage
  from torch import Tensor
  from torch.nn import CosineSimilarity
  from torch.utils.data import DataLoader, TensorDataset
label_desc: Use image node_id 4 for calling the LimeBase obj's underlying member method code with example usage: obj.has_convergence_delta() and returns: False