def _compute_attribution_batch_helper_evaluate(
self,
model,
inputs,
baselines=None,
target=None,
additional_forward_args=None):
ig = IntegratedGradients(model)
if not isinstance(inputs, tuple):
inputs = (inputs, )
if baselines is not None and not isinstance(baselines, tuple):
baselines = (baselines, )
if baselines is None:
baselines = _zeros(inputs)
for method in [
"riemann_right",
"riemann_left",
"riemann_middle",
"riemann_trapezoid",
"gausslegendre",
]:
for internal_batch_size in [None, 1, 20]:
attributions, delta = ig.attribute(
inputs,
baselines,
additional_forward_args=additional_forward_args,
method=method,
n_steps=200,
target=target,
internal_batch_size=internal_batch_size,
return_convergence_delta=True,
)
total_delta = 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=method,
n_steps=200,
target=target,
return_convergence_delta=True,
)
total_delta += abs(delta_indiv).sum().item()
for j in range(len(attributions)):
assertArraysAlmostEqual(
attributions[j][i:i + 1].squeeze(0).tolist(),
attributions_indiv[j].squeeze(0).tolist(),
)
self.assertAlmostEqual(abs(delta).sum().item(),
total_delta,
delta=0.005)
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, 1, 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)):
assertArraysAlmostEqual(
attributions[j][i:i + 1].squeeze(0).tolist(),
attributions_indiv[j].squeeze(0).tolist(),
)
self.assertAlmostEqual(abs(delta).sum().item(),
total_delta,
delta=0.005)
def _compute_attribution_and_evaluate(
self,
model: Module,
inputs: TensorOrTupleOfTensors,
baselines: Optional[Union[Tensor, int, float, Tuple[Union[Tensor, int,
float],
...]]] = None,
target: Optional[int] = None,
additional_forward_args: Any = None,
type: str = "vanilla",
approximation_method: str = "gausslegendre",
) -> Tuple[Tensor, ...]:
r"""
attrib_type: 'vanilla', 'smoothgrad', 'smoothgrad_sq', 'vargrad'
"""
ig = IntegratedGradients(model)
if not isinstance(inputs, tuple):
inputs = cast(TensorOrTupleOfTensors, (inputs, ))
if baselines is not None and not isinstance(baselines, tuple):
baselines = (baselines, )
if baselines is None:
baselines = _tensorize_baseline(inputs, _zeros(inputs))
if type == "vanilla":
attributions, delta = ig.attribute(
inputs,
baselines,
additional_forward_args=additional_forward_args,
method=approximation_method,
n_steps=500,
target=target,
return_convergence_delta=True,
)
model.zero_grad()
attributions_without_delta, delta = ig.attribute(
inputs,
baselines,
additional_forward_args=additional_forward_args,
method=approximation_method,
n_steps=500,
target=target,
return_convergence_delta=True,
)
model.zero_grad()
self.assertEqual([inputs[0].shape[0]], list(delta.shape))
delta_external = ig.compute_convergence_delta(
attributions,
baselines,
inputs,
target=target,
additional_forward_args=additional_forward_args,
)
assertArraysAlmostEqual(delta, delta_external, 0.0)
else:
nt = NoiseTunnel(ig)
n_samples = 5
attributions, delta = nt.attribute(
inputs,
nt_type=type,
n_samples=n_samples,
stdevs=0.00000002,
baselines=baselines,
target=target,
additional_forward_args=additional_forward_args,
method=approximation_method,
n_steps=500,
return_convergence_delta=True,
)
attributions_without_delta = nt.attribute(
inputs,
nt_type=type,
n_samples=n_samples,
stdevs=0.00000002,
baselines=baselines,
target=target,
additional_forward_args=additional_forward_args,
method=approximation_method,
n_steps=500,
)
self.assertEqual([inputs[0].shape[0] * n_samples],
list(delta.shape))
for input, attribution in zip(inputs, attributions):
self.assertEqual(attribution.shape, input.shape)
self.assertTrue(all(abs(delta.numpy().flatten()) < 0.07))
# compare attributions retrieved with and without
# `return_convergence_delta` flag
for attribution, attribution_without_delta in zip(
attributions, attributions_without_delta):
assertTensorAlmostEqual(self,
attribution,
attribution_without_delta,
delta=0.05)
return cast(Tuple[Tensor, ...], attributions)
def _compute_attribution_and_evaluate(
self,
model,
inputs,
baselines=None,
target=None,
additional_forward_args=None,
type="vanilla",
):
r"""
attrib_type: 'vanilla', 'smoothgrad', 'smoothgrad_sq', 'vargrad'
"""
ig = IntegratedGradients(model)
if not isinstance(inputs, tuple):
inputs = (inputs,)
if baselines is not None and not isinstance(baselines, tuple):
baselines = (baselines,)
if baselines is None:
baselines = _zeros(inputs)
for method in [
"riemann_right",
"riemann_left",
"riemann_middle",
"riemann_trapezoid",
"gausslegendre",
]:
if type == "vanilla":
attributions, delta = ig.attribute(
inputs,
baselines,
additional_forward_args=additional_forward_args,
method=method,
n_steps=2000,
target=target,
return_convergence_delta=True,
)
model.zero_grad()
attributions_without_delta, delta = ig.attribute(
inputs,
baselines,
additional_forward_args=additional_forward_args,
method=method,
n_steps=2000,
target=target,
return_convergence_delta=True,
)
model.zero_grad()
self.assertEqual([inputs[0].shape[0]], list(delta.shape))
delta_external = ig.compute_convergence_delta(
attributions,
baselines,
inputs,
target=target,
additional_forward_args=additional_forward_args,
)
assertArraysAlmostEqual(delta, delta_external, 0.0)
else:
nt = NoiseTunnel(ig)
n_samples = 5
attributions, delta = nt.attribute(
inputs,
nt_type=type,
n_samples=n_samples,
stdevs=0.00000002,
baselines=baselines,
target=target,
additional_forward_args=additional_forward_args,
method=method,
n_steps=2000,
return_convergence_delta=True,
)
attributions_without_delta = nt.attribute(
inputs,
nt_type=type,
n_samples=n_samples,
stdevs=0.00000002,
baselines=baselines,
target=target,
additional_forward_args=additional_forward_args,
method=method,
n_steps=2000,
)
self.assertEqual([inputs[0].shape[0] * n_samples], list(delta.shape))
for input, attribution in zip(inputs, attributions):
self.assertEqual(attribution.shape, input.shape)
self.assertTrue(all(abs(delta.numpy().flatten()) < 0.05))
# compare attributions retrieved with and without
# `return_convergence_delta` flag
for attribution, attribution_without_delta in zip(
attributions, attributions_without_delta
):
assertTensorAlmostEqual(
self, attribution, attribution_without_delta, delta=0.05
)
return attributions
