re-run ruff

Author: justinkang221

docs/source/notebooks/language_notebooks/language_model_game.ipynb

@@ -502,22 +502,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "text = \\\n",
-    "\"\"\"\n",
+    "text = \"\"\"\n",
     "shapiq is a valuable Python library designed for Explainable AI (XAI), focusing specifically on approaches like\n",
     "Shapley values and their extensions. Its core strength lies in providing a unified framework to compute not only individual feature attributions but also sophisticated interaction indices (e.g., Shapley Interaction Index, Banzhaf Index). This allows users to gain deeper insights into how features collaborate or conflict within complex machine learning models, going beyond simple importance scores. A notable weakness stems from the inherent computational complexity of these game-theoretic measures. Calculating exact values, especially for higher-order interactions, is often infeasible, and even approximations can be computationally intensive and time-consuming, particularly for models with many features or large datasets. Despite this, shapiq remains a powerful tool for detailed model inspection.\n",
     "\"\"\"\n",
-    "big_game = SentimentClassificationGame(classifier=classifier,\n",
-    "                                       tokenizer=tokenizer,\n",
-    "                                       test_sentence=text)\n",
+    "big_game = SentimentClassificationGame(\n",
+    "    classifier=classifier, tokenizer=tokenizer, test_sentence=text\n",
+    ")\n",
     "print(f\"There are a total of {big_game.n_players} players.\")\n",
     "# To speed up inference, run pipeline with gpu support. Takes ~10 minutes on Mac M1 with MPS.\n",
     "scalable_approximator = shapiq.SPEX(n=big_game.n_players, index=\"SII\")\n",
     "large_sii = scalable_approximator.approximate(budget=32000, game=big_game)\n",
     "print(f\"Game for the full coalition: {game_class(full_coalition)[0]}\")\n",
     "print(f\"Game for the empty coalition: {game_class(empty_coalition)[0]}\")\n",
-    "interactions = (list(large_sii.dict_values.items()))\n",
-    "interactions.sort(key= lambda x : abs(x[1]), reverse=True)"
+    "interactions = list(large_sii.dict_values.items())\n",
+    "interactions.sort(key=lambda x: abs(x[1]), reverse=True)"
    ]
   },
   {
@@ -557,7 +556,7 @@
    "source": [
     "for inter, value in interactions[:10]:\n",
     "    tokens = [big_game.tokenizer.decode(big_game.tokenized_input[idx]) for idx in inter]\n",
-    "    print(f'Tokens: {tokens}, Value: {value:.3f}')"
+    "    print(f\"Tokens: {tokens}, Value: {value:.3f}\")"
    ]
   }
  ],

docs/source/notebooks/vision_notebooks/vision_transformer.ipynb

@@ -371,9 +371,11 @@
     "    x_explain_path=image_path,\n",
     ")\n",
     "print(\"Number of players:\", big_game.n_players)  # the image is transformed into 36 patches\n",
-    "print('Takes ~6min on an M1 Macbook Pro')\n",
+    "print(\"Takes ~6min on an M1 Macbook Pro\")\n",
     "# For 36 patches, consider using order 1 for simpler explanations\n",
-    "scalable_approximator = shapiq.SPEX(n=big_game.n_players, max_order=2, index=\"SII\") # Here we use max order=2,\n",
+    "scalable_approximator = shapiq.SPEX(\n",
+    "    n=big_game.n_players, max_order=2, index=\"SII\"\n",
+    ")  # Here we use max order=2,\n",
     "large_sii = scalable_approximator.approximate(budget=9000, game=big_game)\n",
     "large_sii.plot_network(center_image=center_image, draw_legend=False)"
    ]

pyproject.toml

@@ -15,12 +15,12 @@ dependencies = [
     "scikit-learn",
     "tqdm",
     "requests",
+    "sparse-transform",
+    "galois",
     # plotting
     "matplotlib",
     "networkx",
     "colour",
-    "sparse-transform",
-    "galois",
 ]
 authors = [
     {name = "Maximilian Muschalik", email = "Maximilian.Muschalik@lmu.de"},

shapiq/approximator/sparse/_base.py

@@ -81,7 +81,9 @@ def __init__(
             "num_repeat": 1,
             "reconstruct_method_source": "coded",
             "peeling_method": "multi-detect",
-            "reconstruct_method_channel": "identity-siso" if self.decoder_type == "soft" else "identity",
+            "reconstruct_method_channel": "identity-siso"
+            if self.decoder_type == "soft"
+            else "identity",
             "regress": "lasso",
             "res_energy_cutoff": 0.9,
             "source_decoder": get_bch_decoder(n, self.t, self.decoder_type),
@@ -96,7 +98,9 @@ def __init__(
         )
 
     def approximate(
-        self, budget: int, game: Callable[[np.ndarray], np.ndarray],
+        self,
+        budget: int,
+        game: Callable[[np.ndarray], np.ndarray],
     ) -> InteractionValues:
         """Approximates the interaction values using a sparse transform approach.
 
@@ -109,11 +113,12 @@ def approximate(
         """
         # Find the maximum value of b that fits within the given sample budget and get the used budget
         used_budget = self._set_transform_budget(budget)
-        signal = SubsampledSignalFourier(func=lambda inputs: game(inputs.astype(bool)),
-                                         n=self.n,
-                                         q=2,
-                                         query_args=self.query_args,
-                                         )
+        signal = SubsampledSignalFourier(
+            func=lambda inputs: game(inputs.astype(bool)),
+            n=self.n,
+            q=2,
+            query_args=self.query_args,
+        )
         # Extract the coefficients of the original transform
         initial_transform = {
             tuple(np.nonzero(key)[0]): np.real(value)
@@ -142,7 +147,6 @@ def approximate(
             output = self.aggregate_interaction_values(output)
         return output
 
-
     def _filter_order(self, result: np.ndarray) -> np.ndarray:
         """Filters the interactions to keep only those of the maximum order.
 
@@ -232,7 +236,9 @@ def _set_transform_budget(self, budget: int) -> int:
 
                 # Break if 'b' is now sufficient
                 if b > 2:
-                    self.decoder_args["source_decoder"] = get_bch_decoder(self.n, self.t, self.decoder_type)
+                    self.decoder_args["source_decoder"] = get_bch_decoder(
+                        self.n, self.t, self.decoder_type
+                    )
                     break
 
             # If 'b' is still too low, raise an error

shapiq/benchmark/configuration.py

@@ -745,7 +745,10 @@
     dict.fromkeys(SV_APPROXIMATORS, ("n", "random_state")),
 )
 APPROXIMATION_BENCHMARK_PARAMS.update(
-    dict.fromkeys(SI_APPROXIMATORS + SII_APPROXIMATORS + STII_APPROXIMATORS + FSII_APPROXIMATORS, ("n", "random_state", "index", "max_order")),
+    dict.fromkeys(
+        SI_APPROXIMATORS + SII_APPROXIMATORS + STII_APPROXIMATORS + FSII_APPROXIMATORS,
+        ("n", "random_state", "index", "max_order"),
+    ),
 )
 
 

shapiq/games/benchmark/_setup/_vit_setup.py

@@ -147,30 +147,24 @@ def _transform_coalition_into_bool_mask(coalition: np.ndarray, n_patches: int) -
         bool_mask_2d = torch.ones((12, 12), dtype=torch.int)
 
         # Calculate the size of each super-patch based on the grid size
-        patch_size = 12 // int(n_patches ** 0.5)
+        patch_size = 12 // int(n_patches**0.5)
 
         for player, is_present in enumerate(coalition):
             if is_present:
                 x, y = (
                     MAPPING_PLAYER_MASK[n_patches][player]["x"],
                     MAPPING_PLAYER_MASK[n_patches][player]["y"],
                 )
-                bool_mask_2d[y:y + patch_size, x:x + patch_size] = 0
+                bool_mask_2d[y : y + patch_size, x : x + patch_size] = 0
 
         bool_mask_1d = bool_mask_2d.flatten()
         return bool_mask_1d
 
 
 # constants for the boolean mask generation for the Vision Transformer model
 MAPPING_PLAYER_MASK = {
-    36: {
-        player: {"x": (player % 6) * 2, "y": (player // 6) * 2}
-        for player in range(36)
-    },
-    144: {
-        player: {"x": player % 12, "y": player // 12}
-        for player in range(144)
-    },
+    36: {player: {"x": (player % 6) * 2, "y": (player // 6) * 2} for player in range(36)},
+    144: {player: {"x": player % 12, "y": player // 12} for player in range(144)},
     16: {
         0: {"x": 0, "y": 0},
         1: {"x": 3, "y": 0},

shapiq/games/benchmark/local_xai/benchmark_image.py

@@ -80,11 +80,15 @@ def __init__(
             raise ValueError(msg)
 
         # validate inputs
-        valid_models = ["vit_144_patches", "vit_36_patches", "vit_16_patches", "vit_9_patches", "resnet_18"]
+        valid_models = [
+            "vit_144_patches",
+            "vit_36_patches",
+            "vit_16_patches",
+            "vit_9_patches",
+            "resnet_18",
+        ]
         if model_name.lower() not in valid_models:
-            msg = (
-                f"Invalid model {model_name}. The model must be one of {valid_models}"
-            )
+            msg = f"Invalid model {model_name}. The model must be one of {valid_models}"
             raise ValueError(
                 msg,
             )
@@ -104,7 +108,7 @@ def __init__(
                 "vit_144_patches": 144,
                 "vit_36_patches": 36,
                 "vit_16_patches": 16,
-                "vit_9_patches": 9
+                "vit_9_patches": 9,
             }
             n_players = patch_sizes[model_name]
 

tests/tests_approximators/test_approximator_base_sparse.py

@@ -1,4 +1,5 @@
 """This test module contains all tests regarding the base sparse approximator."""
+
 from __future__ import annotations
 
 import pytest
@@ -188,7 +189,7 @@ def test_approximate(
     # generate the set of expected interactions
     expected_interactions = set()
     if estimates.min_order == 0:
-        expected_interactions.update( {(i,) for i in range(n)} )
+        expected_interactions.update({(i,) for i in range(n)})
     if estimates.max_order > 1:
         expected_interactions.add(interaction)
 

tests/tests_approximators/test_approximator_spex.py

@@ -125,6 +125,7 @@ def test_spex_vs_sparse():
     # Check that the interaction is estimated similarly
     assert abs(spex_estimates[interaction] - sparse_estimates[interaction]) < 0.1
 
+
 @pytest.mark.parametrize(
     "n, interaction, budget, correct_b, correct_t",
     [
@@ -148,6 +149,7 @@ def test_sparsity_parameter(n, interaction, budget, correct_b, correct_t):
     assert spex.query_args["b"] == correct_b
     assert spex.t == correct_t
 
+
 @pytest.mark.parametrize(
     "n, interaction, budget",
     [