code: def _conductance_input_test_assert(
      self,
      model: Module,
      target_layer: Module,
      test_input: TensorOrTupleOfTensorsGeneric,
      test_neuron: Union[int, Tuple[int, ...], Callable],
      expected_input_conductance: Union[
          List[float], Tuple[List[List[float]], ...]
      ],
      additional_input: Any = None,
      multiply_by_inputs: bool = True,
  ) -> None:
      for internal_batch_size in (None, 5, 20):
          cond = NeuronConductance(
              model,
              target_layer,
              multiply_by_inputs=multiply_by_inputs,
          )
          self.assertEqual(
              cond.multiplies_by_inputs, multiply_by_inputs
          )
          attributions = cond.attribute(
              test_input,
              test_neuron,
              target=0,
              n_steps=500,
              method="gausslegendre",
              additional_forward_args=additional_input,
              internal_batch_size=internal_batch_size,
          )
          if isinstance(expected_input_conductance, tuple):
              for i in range(len(expected_input_conductance)):
                  for j in range(len(expected_input_conductance[i])):
                      assertTensorAlmostEqual(
                          self,
                          attributions[i][j : j + 1].squeeze(0),
                          expected_input_conductance[i][j],
                          delta=0.1,
                          mode="max",
                      )
          else:
              if isinstance(attributions, Tensor):
                  assertTensorAlmostEqual(
                      self,
                      attributions.squeeze(0),
                      expected_input_conductance,
                      delta=0.1,
                      mode="max",
                  )
              else:
                  raise AssertionError(
                      "Attributions not returning a Tensor when expected."
                  )
  
imports: import unittest
  from typing import Any, Callable, cast, List, Tuple, Union
  import torch
  from captum._utils.typing import BaselineType, TensorOrTupleOfTensorsGeneric
  from captum.attr._core.layer.layer_conductance import LayerConductance
  from captum.attr._core.neuron.neuron_conductance import NeuronConductance
  from tests.helpers.basic import assertTensorAlmostEqual, BaseTest
  from tests.helpers.basic_models import BasicModel_ConvNet, BasicModel_MultiLayer, BasicModel_MultiLayer_MultiInput
  from torch import Tensor
  from torch.nn import Module
label_desc: Use image node_id 15 for calling the Test obj's underlying member method code with example usage: obj._conductance_input_test_assert(model, target_layer, test_input, test_neuron, expected_input_conductance, additional_input, multiply_by_inputs) without return types