Remove zeros from interaction lookup, check in test (mmschlk#424)

* remove zeros from interaction lookup, check in test

* remove debug statements

* fix pre-commit issues

* remove interaction values if they are summed to zero, add reproducible tests

---------

Co-authored-by: Maximilian <[email protected]>

Author: CloseChoice

src/shapiq/game_theory/aggregation.py

@@ -72,10 +72,14 @@ def aggregate_base_attributions(
         for interaction in powerset(base_interaction, min_size=1, max_size=order):
             scaling = float(bernoulli_numbers[len(base_interaction) - len(interaction)])
             update_interaction = scaling * base_interaction_value
-            try:
-                transformed_interactions[interaction] += update_interaction
-            except KeyError:
-                transformed_interactions[interaction] = update_interaction
+            if update_interaction == 0:
+                continue
+            transformed_interactions[interaction] = (
+                transformed_interactions.get(interaction, 0) + update_interaction
+            )
+            # if the interactions sum to 0, we pop them from the dict
+            if transformed_interactions[interaction] == 0:
+                transformed_interactions.pop(interaction)
 
     # update the index name after the aggregation (e.g., SII -> k-SII)
     new_index = _change_index(index)

src/shapiq/game_theory/moebius_converter.py

@@ -157,14 +157,17 @@ def _moebius_to_base_interaction(
             strict=False,
         ):
             moebius_size = len(moebius_set)
-            # for higher-order Möbius sets (size > order) distribute the value on all interactions
             for interaction in powerset(moebius_set, min_size=0, max_size=order):
                 val_distributed = distribution_weights[moebius_size, len(interaction)]
                 # Check if Möbius value is distributed onto this interaction
-                if interaction in base_interaction_dict:
-                    base_interaction_dict[interaction] += moebius_val * val_distributed
-                else:
-                    base_interaction_dict[interaction] = moebius_val * val_distributed
+                moebius_val_calc = moebius_val * val_distributed
+                if moebius_val_calc == 0:
+                    continue
+                base_interaction_dict[interaction] = (
+                    base_interaction_dict.get(interaction, 0) + moebius_val_calc
+                )
+                if base_interaction_dict[interaction] == 0:
+                    base_interaction_dict.pop(interaction)
 
         base_interaction_values = np.zeros(len(base_interaction_dict))
         base_interaction_lookup = {}
@@ -227,19 +230,24 @@ def _stii_routine(
             if moebius_size < order:
                 # For STII, interaction below size order are the Möbius coefficients
                 val_distributed = distribution_weights[moebius_size, moebius_size]
-                if moebius_set in stii_dict:
-                    stii_dict[moebius_set] += moebius_val * val_distributed
-                else:
-                    stii_dict[moebius_set] = moebius_val * val_distributed
+                moebius_val_calc = moebius_val * val_distributed
+                if moebius_val_calc == 0:
+                    continue
+                stii_dict[moebius_set] = stii_dict.get(moebius_set, 0) + moebius_val_calc
+                # if Möbius values sum up to zero, we pop it from the dict
+                if stii_dict[moebius_set] == 0:
+                    stii_dict.pop(moebius_set)
             else:
                 # higher-order Möbius sets (size > order) distribute to all top-order interactions
                 for interaction in powerset(moebius_set, min_size=order, max_size=order):
                     val_distributed = distribution_weights[moebius_size, len(interaction)]
                     # Check if Möbius value is distributed onto this interaction
-                    if interaction in stii_dict:
-                        stii_dict[interaction] += moebius_val * val_distributed
-                    else:
-                        stii_dict[interaction] = moebius_val * val_distributed
+                    moebius_val_calc = moebius_val * val_distributed
+                    if moebius_val_calc == 0:
+                        continue
+                    stii_dict[interaction] = stii_dict.get(interaction, 0) + moebius_val_calc
+                    if stii_dict[interaction] == 0:
+                        stii_dict.pop(interaction)
 
         stii_values = np.zeros(len(stii_dict))
         stii_lookup = {}
@@ -311,10 +319,13 @@ def _fii_routine(self, index: Literal["FSII", "FBII"], order: int) -> Interactio
             for interaction in powerset(moebius_set, min_size=1, max_size=order):
                 val_distributed = distribution_weights[moebius_size, len(interaction)]
                 # Check if Möbius value is distributed onto this interaction
-                if interaction in fii_dict:
-                    fii_dict[interaction] += moebius_val * val_distributed
-                else:
-                    fii_dict[interaction] = moebius_val * val_distributed
+                moebius_val_calc = moebius_val * val_distributed
+                if moebius_val_calc == 0:
+                    continue
+                fii_dict[interaction] = fii_dict.get(interaction, 0) + moebius_val_calc
+                # if Möbius values sum up to zero, we pop it from the dict
+                if fii_dict[interaction] == 0:
+                    fii_dict.pop(interaction)
 
         fii_values = np.zeros(len(fii_dict))
         fii_lookup = {}

tests/shapiq/tests_unit/tests_game_theory/test_moebius_converter.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import numpy as np
+import pytest
 
 from shapiq.game_theory.moebius_converter import MoebiusConverter
 from shapiq_games.synthetic.soum import SOUM
@@ -22,13 +23,43 @@ def test_soum_moebius_conversion():
 
         moebius_converter = MoebiusConverter(soum.moebius_coefficients)
 
-        shapley_interactions = {}
         for index in ["STII", "k-SII", "FSII"]:
-            shapley_interactions[index] = moebius_converter(index=index, order=order)
+            shapley_interactions = moebius_converter(index=index, order=order)
             # Assert efficiency
-            assert (np.sum(shapley_interactions[index].values) - predicted_value) ** 2 < 10e-7
-            assert (shapley_interactions[index][()] - emptyset_prediction) ** 2 < 10e-7
+            assert (np.sum(shapley_interactions.values) - predicted_value) ** 2 < 10e-7
+            assert (shapley_interactions[()] - emptyset_prediction) ** 2 < 10e-7
+            for v in moebius_converter._computed.values():
+                # check that no 0's are in the interaction lookup (except for the empty set, which is the first entry)
+                interactions = v.interactions
+                assert all(v != 0 for idx, v in enumerate(interactions.values()) if idx > 0)
 
         # test direct call of Möbius converter
         for index in ["STII", "k-SII", "SII", "FSII"]:
             moebius_converter(index=index, order=order)
+
+
+@pytest.mark.parametrize("random_state", [10, 19, 20, 21, 23])
+def test_soum_moebius_conversion_failing_states(random_state):
+    """Test SOUM moebius conversion with specific failing random states."""
+    order = 3
+    n_basis_games = 1
+    n = 7
+
+    soum = SOUM(n, n_basis_games=n_basis_games, random_state=random_state)
+    predicted_value = soum(np.ones(n))[0]
+    emptyset_prediction = soum(np.zeros(n))[0]
+
+    moebius_converter = MoebiusConverter(soum.moebius_coefficients)
+
+    for index in ["STII", "k-SII", "FSII"]:
+        shapley_interactions = moebius_converter(index=index, order=order)
+        # Assert efficiency
+        assert (np.sum(shapley_interactions.values) - predicted_value) ** 2 < 10e-7
+        assert (shapley_interactions[()] - emptyset_prediction) ** 2 < 10e-7
+        for v in moebius_converter._computed.values():
+            interactions = v.interactions
+            # Check that no 0's are in the interaction values (except for empty set)
+            non_empty_values = [val for idx, val in enumerate(interactions.values()) if idx > 0]
+            assert all(val != 0 for val in non_empty_values), (
+                f"Found zero values in non-empty interactions with random state {random_state}"
+            )