def test_simple_conductance_multi_input_linear2(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[0.0, 10.0, 0.0]])
inp2 = torch.tensor([[0.0, 10.0, 0.0]])
inp3 = torch.tensor([[0.0, 5.0, 0.0]])
self._conductance_input_test_assert(
net,
net.model.linear2,
(inp1, inp2, inp3),
(0, ),
([[0.0, 156.0, 0.0]], [[0.0, 156.0, 0.0]], [[0.0, 78.0, 0.0]]),
(4, ),
)
def test_simple_gradient_multi_input_linear1(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[0.0, 100.0, 0.0]])
inp2 = torch.tensor([[0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 0.0]])
self._gradient_input_test_assert(
net,
net.model.linear1,
(inp1, inp2),
(0,),
([[5.0, 5.0, 5.0]], [[5.0, 5.0, 5.0]]),
(inp3, 5),
)
def test_simple_ig_multi_input_relu(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[0.0, 6.0, 14.0]])
inp2 = torch.tensor([[0.0, 6.0, 14.0]])
inp3 = torch.tensor([[0.0, 0.0, 0.0]])
self._ig_input_test_assert(
net,
net.model.relu,
(inp1, inp2),
(0, ),
([[0.0, 1.5, 3.5]], [[0.0, 1.5, 3.5]]),
(inp3, 0.5),
)
def test_simple_conductance_multi_input_relu(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[0.0, 10.0, 1.0]])
inp2 = torch.tensor([[0.0, 4.0, 5.0]])
inp3 = torch.tensor([[0.0, 0.0, 0.0]])
self._conductance_input_test_assert(
net,
net.model.relu,
(inp1, inp2),
(3, ),
([[0.0, 50.0, 5.0]], [[0.0, 20.0, 25.0]]),
(inp3, 5),
)
def test_basic_multi_input(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inputs = (torch.tensor([[10.0, 20.0,
10.0]]), torch.tensor([[1.0, 2.0, 1.0]]))
add_args = (torch.tensor([[1.0, 2.0, 3.0]]), 1.0)
baselines = (torch.randn(30, 3), torch.randn(30, 3))
expected = torch.tensor([[171.6841, 0.0]])
self._assert_attributions(net,
net.model.linear2,
inputs,
baselines,
0,
expected,
add_args=add_args)
def test_simple_ig_multi_input_relu_batch_selector_fn(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[0.0, 6.0, 14.0], [0.0, 80.0, 0.0]])
inp2 = torch.tensor([[0.0, 6.0, 14.0], [0.0, 20.0, 0.0]])
inp3 = torch.tensor([[0.0, 0.0, 0.0], [0.0, 20.0, 0.0]])
self._ig_input_test_assert(
net,
net.model.relu,
(inp1, inp2),
lambda x: torch.sum(x),
(
[[0.0, 10.5, 24.5], [0.0, 160.0, 0.0]],
[[0.0, 10.5, 24.5], [0.0, 40.0, 0.0]],
),
(inp3, 0.5),
)
def test_multi_input_kernel_shap_without_mask(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 0.0, 0.0]])
inp2 = torch.tensor([[20.0, 0.0, 50.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0]])
expected = (
[[90, 0, 0]],
[[78, 0, 198]],
[[0, 398, 38]],
)
self._kernel_shap_test_assert(
net,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
n_samples=2000,
)
def test_multi_input_ablation_with_mask_nt(self) -> None:
ablation_algo = NoiseTunnel(
FeatureAblation(BasicModel_MultiLayer_MultiInput()))
inp1 = torch.tensor([[23.0, 100.0, 0.0], [20.0, 50.0, 30.0]])
inp2 = torch.tensor([[20.0, 50.0, 30.0], [0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0], [2.0, 10.0, 3.0]])
mask1 = torch.tensor([[1, 1, 1], [0, 1, 0]])
mask2 = torch.tensor([[0, 1, 2]])
mask3 = torch.tensor([[0, 1, 2], [0, 0, 0]])
expected = (
[[492.0, 492.0, 492.0], [200.0, 200.0, 200.0]],
[[80.0, 200.0, 120.0], [0.0, 400.0, 0.0]],
[[0.0, 400.0, 40.0], [60.0, 60.0, 60.0]],
)
self._ablation_test_assert(
ablation_algo,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
stdevs=1e-10,
)
self._ablation_test_assert(
ablation_algo,
(inp1, inp2),
expected[0:1],
additional_input=(inp3, 1),
feature_mask=(mask1, mask2),
perturbations_per_eval=(1, 2, 3),
stdevs=1e-10,
)
expected_with_baseline = (
[[468.0, 468.0, 468.0], [184.0, 192.0, 184.0]],
[[68.0, 188.0, 108.0], [-12.0, 388.0, -12.0]],
[[-16.0, 384.0, 24.0], [12.0, 12.0, 12.0]],
)
self._ablation_test_assert(
ablation_algo,
(inp1, inp2, inp3),
expected_with_baseline,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
baselines=(2, 3.0, 4),
perturbations_per_eval=(1, 2, 3),
stdevs=1e-10,
)
def test_multi_input_shapley_sampling_without_mask(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 0.0, 0.0], [20.0, 50.0, 30.0]])
inp2 = torch.tensor([[20.0, 0.0, 50.0], [0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0], [0.0, 10.0, 0.0]])
expected = (
[[90, 0, 0], [78.0, 198.0, 118.0]],
[[78, 0, 198], [0.0, 398.0, 0.0]],
[[0, 398, 38], [0.0, 38.0, 0.0]],
)
self._shapley_test_assert(
net,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
n_samples=200,
test_true_shapley=False,
)
def test_multi_input_lime_without_mask(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 0.0, 0.0]])
inp2 = torch.tensor([[20.0, 0.0, 50.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0]])
expected = (
[[87, 0, 0]],
[[75, 0, 195]],
[[0, 395, 35]],
)
self._lime_test_assert(
net,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
n_perturb_samples=2000,
expected_coefs_only=[87, 0, 0, 75, 0, 195, 0, 395, 35],
)
def test_multi_input_batch_lime(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 100.0, 0.0], [20.0, 50.0, 30.0]])
inp2 = torch.tensor([[20.0, 50.0, 30.0], [0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0], [2.0, 10.0, 3.0]])
mask1 = torch.tensor([[1, 1, 1], [0, 1, 0]])
mask2 = torch.tensor([[0, 1, 2]])
mask3 = torch.tensor([[0, 1, 2], [0, 0, 0]])
expected = (
[[1086.2802, 1086.2802, 1086.2802], [250.8907, 590.9789,
250.8907]],
[[73.2166, 1086.2802, 152.6888], [250.8907, 590.9789, 0.0000]],
[[73.2166, 1086.2802, 152.6888], [250.8907, 250.8907, 250.8907]],
)
self._lime_test_assert(
net,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
)
expected_with_baseline = (
[[1036.4233, 1036.4233, 1036.4233], [180.3035, 575.8969,
180.3035]],
[[48.2441, 1036.4233, 128.3161], [180.3035, 575.8969, -8.3229]],
[[48.2441, 1036.4233, 128.3161], [180.3035, 180.3035, 180.3035]],
)
self._lime_test_assert(
net,
(inp1, inp2, inp3),
expected_with_baseline,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
baselines=(2, 3.0, 4),
perturbations_per_eval=(1, 2, 3),
expected_coefs_only=[
[48.2441, 1036.4233, 128.3161],
[180.3035, 575.8969, -8.3229],
],
n_samples=500,
test_generator=True,
)
def test_multi_input_lime_with_mask(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[20.0, 50.0, 30.0]])
inp2 = torch.tensor([[0.0, 100.0, 0.0]])
inp3 = torch.tensor([[2.0, 10.0, 3.0]])
mask1 = torch.tensor([[0, 1, 0]])
mask2 = torch.tensor([[0, 1, 2]])
mask3 = torch.tensor([[0, 0, 0]])
expected = (
[[251.0, 591.0, 251.0]],
[[251.0, 591.0, 0.0]],
[[251.0, 251.0, 251.0]],
)
self._lime_test_assert(
net,
(inp1, inp2, inp3),
expected,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
n_samples=500,
expected_coefs_only=[251.0, 591.0, 0.0],
)
expected_with_baseline = (
[[180, 576.0, 180]],
[[180, 576.0, -8.0]],
[[180, 180, 180]],
)
self._lime_test_assert(
net,
(inp1, inp2, inp3),
expected_with_baseline,
additional_input=(1, ),
feature_mask=(mask1, mask2, mask3),
baselines=(2, 3.0, 4),
perturbations_per_eval=(1, 2, 3),
n_samples=500,
expected_coefs_only=[180, 576.0, -8.0],
test_generator=True,
)
def test_multi_input_ablation_with_baselines(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 100.0, 0.0], [20.0, 50.0, 30.0]])
inp2 = torch.tensor([[20.0, 50.0, 30.0], [0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0], [2.0, 10.0, 3.0]])
expected = (
[[444.0, 444.0, 444.0], [328.0, 328.0, 328.0]],
[[68.0, 188.0, 108.0], [-12.0, 388.0, -12.0]],
[[368.0, 368.0, 24.0], [0.0, 0.0, -12.0]],
)
self._occlusion_test_assert(
net,
(inp1, inp2, inp3),
expected,
baselines=(
torch.tensor([[1.0, 4, 7], [3.0, 6, 9]]),
3.0,
torch.tensor([[4.0], [6]]),
),
additional_input=(1, ),
sliding_window_shapes=((3, ), (1, ), (2, )),
strides=(2, 1, 2),
)
def test_multi_input_ablation(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
inp1 = torch.tensor([[23.0, 100.0, 0.0], [20.0, 50.0, 30.0]])
inp2 = torch.tensor([[20.0, 50.0, 30.0], [0.0, 100.0, 0.0]])
inp3 = torch.tensor([[0.0, 100.0, 10.0], [2.0, 10.0, 3.0]])
baseline1 = torch.tensor([[3.0, 0.0, 0.0]])
baseline2 = torch.tensor([[0.0, 1.0, 0.0]])
baseline3 = torch.tensor([[1.0, 2.0, 3.0]])
self._ablation_test_assert(
net,
net.model.linear2,
(inp1, inp2, inp3),
(
[[80.0, 400.0, 0.0], [68.0, 200.0, 120.0]],
[[80.0, 196.0, 120.0], [0.0, 396.0, 0.0]],
[[-4.0, 392.0, 28.0], [4.0, 32.0, 0.0]],
),
additional_input=(1, ),
baselines=(baseline1, baseline2, baseline3),
perturbations_per_eval=(1, 2, 3),
)
baseline1_exp = torch.tensor([[3.0, 0.0, 0.0], [3.0, 0.0, 2.0]])
baseline2_exp = torch.tensor([[0.0, 1.0, 0.0], [0.0, 1.0, 4.0]])
baseline3_exp = torch.tensor([[3.0, 2.0, 4.0], [1.0, 2.0, 3.0]])
self._ablation_test_assert(
net,
net.model.linear2,
(inp1, inp2, inp3),
(
[[80.0, 400.0, 0.0], [68.0, 200.0, 112.0]],
[[80.0, 196.0, 120.0], [0.0, 396.0, -16.0]],
[[-12.0, 392.0, 24.0], [4.0, 32.0, 0.0]],
),
additional_input=(1, ),
baselines=(baseline1_exp, baseline2_exp, baseline3_exp),
perturbations_per_eval=(1, 2, 3),
)
def test_multi_inp_lime_scalar_float(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_scalar_lime_assert(
lambda *inp: torch.sum(net(*inp)).item())
def test_multi_inp_lime_scalar_tensor_1d(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_scalar_lime_assert(
lambda *inp: torch.sum(net(*inp)).reshape(1))
{
"name": "basic_multi_input",
"algorithms": [
IntegratedGradients,
InputXGradient,
FeatureAblation,
DeepLift,
Saliency,
GuidedBackprop,
Deconvolution,
ShapleyValueSampling,
FeaturePermutation,
Lime,
KernelShap,
],
"model": BasicModel_MultiLayer_MultiInput(),
"attribute_args": {
"inputs": (10 * torch.randn(12, 3), 5 * torch.randn(12, 3)),
"additional_forward_args": (2 * torch.randn(12, 3), 5),
"target": 0,
},
"dp_delta": 0.0003,
},
{
"name": "basic_multi_target",
"algorithms": [
IntegratedGradients,
InputXGradient,
FeatureAblation,
DeepLift,
Saliency,
def test_mutli_inp_ablation_batch_scalar_tensor_int(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
ablation_algo = FeatureAblation(
lambda *inp: int(torch.sum(net(*inp)).item()))
self._multi_input_batch_scalar_ablation_assert(ablation_algo,
dtype=torch.int64)
def test_multi_inp_ablation_batch_scalar_tensor_1d(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
ablation_algo = FeatureAblation(
lambda *inp: torch.sum(net(*inp)).reshape(1))
self._multi_input_batch_scalar_ablation_assert(ablation_algo)
def test_multi_inp_ablation_batch_scalar_float(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_batch_scalar_ablation_assert(
lambda *inp: torch.sum(net(*inp)).item(),
dtype=torch.float64,
)
def test_multi_inp_ablation_batch_scalar_tensor_0d(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_batch_scalar_ablation_assert(
lambda *inp: torch.sum(net(*inp))
)
def test_mutli_inp_shapley_batch_scalar_tensor_int(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_batch_scalar_shapley_assert(
lambda *inp: int(torch.sum(net(*inp)).item()))
def test_multi_inp_kernel_shap_scalar_tensor_0d(self) -> None:
net = BasicModel_MultiLayer_MultiInput()
self._multi_input_scalar_kernel_shap_assert(
lambda *inp: torch.sum(net(*inp)))
