code: def _compute_attribution_batch_helper_evaluate(
      self,
      model: Module,
      inputs: TensorOrTupleOfTensorsGeneric,
      baselines: Union[None, Tensor, Tuple[Tensor, ...]] = None,
      target: Union[None, int] = None,
      additional_forward_args: Any = None,
      approximation_method: str = "gausslegendre",
  ) -> None:
      ig = IntegratedGradients(model)
      if not isinstance(inputs, tuple):
          inputs = (inputs,)  # type: ignore
      inputs: Tuple[Tensor, ...]
  
      if baselines is not None and not isinstance(baselines, tuple):
          baselines = (baselines,)
  
      if baselines is None:
          baselines = _tensorize_baseline(inputs, _zeros(inputs))
  
      for internal_batch_size in [None, 10, 20]:
          attributions, delta = ig.attribute(
              inputs,
              baselines,
              additional_forward_args=additional_forward_args,
              method=approximation_method,
              n_steps=100,
              target=target,
              internal_batch_size=internal_batch_size,
              return_convergence_delta=True,
          )
          total_delta = 0.0
          for i in range(inputs[0].shape[0]):
              attributions_indiv, delta_indiv = ig.attribute(
                  tuple(input[i : i + 1] for input in inputs),
                  tuple(baseline[i : i + 1] for baseline in baselines),
                  additional_forward_args=additional_forward_args,
                  method=approximation_method,
                  n_steps=100,
                  target=target,
                  internal_batch_size=internal_batch_size,
                  return_convergence_delta=True,
              )
              total_delta += abs(delta_indiv).sum().item()
              for j in range(len(attributions)):
                  assertTensorAlmostEqual(
                      self,
                      attributions[j][i : i + 1].squeeze(0),
                      attributions_indiv[j].squeeze(0),
                      delta=0.05,
                      mode="max",
                  )
          self.assertAlmostEqual(
              abs(delta).sum().item(), total_delta, delta=0.005
          )
  
imports: import unittest
  from typing import Any, cast, Tuple, Union
  import torch
  from captum._utils.common import _zeros
  from captum._utils.typing import BaselineType, Tensor, TensorOrTupleOfTensorsGeneric
  from captum.attr._core.integrated_gradients import IntegratedGradients
  from captum.attr._core.noise_tunnel import NoiseTunnel
  from captum.attr._utils.common import _tensorize_baseline
  from tests.helpers.basic import assertTensorAlmostEqual, BaseTest
  from tests.helpers.basic_models import BasicModel, BasicModel2, BasicModel3, BasicModel4_MultiArgs, BasicModel5_MultiArgs, BasicModel6_MultiTensor, BasicModel_MultiLayer
  from torch.nn import Module
label_desc: Use image node_id 41 for calling the Test obj's underlying member method code with example usage: obj._compute_attribution_batch_helper_evaluate(model, inputs, baselines, target, additional_forward_args, approximation_method) without return types