fix: route the SHAP predictor through predict_prepared

as_shap_predictor handed SHAP a closure over model.predict. The callers
(KernelShap, RegressionKernelShap, ContrastiveShap) first move the
background into the model's feature space with prepare_model_input, so
going through predict ran the model's input preparation a second time
over an already prepared matrix. SHAP then perturbs that matrix into
plain arrays, which the preparation cannot consume at all, and the
failure surfaced far from its cause as

    AttributeError: 'numpy.ndarray' object has no attribute 'types'

The module docstring and a comment above each caller already said the
model had to be queried through predict_prepared; only the call was
left behind.

test_the_wrapped_predictor_never_routes_through_predict pins it: its
stub raises if predict is reached, so a future regression fails at the
wrapper instead of five frames away inside SHAP.

Author: Felipedino

DashAI/back/explainability/model_input.py

@@ -24,7 +24,7 @@
 
 
 def as_shap_predictor(model: Any) -> Callable:
-    """Wrap ``model.predict`` so SHAP receives a plain function, not a method.
+    """Wrap the model's prepared-matrix prediction so SHAP gets a plain function.
 
     SHAP suppresses scikit-learn's "X does not have valid feature names"
     warning by blanking ``feature_names_in_`` on whatever object the callable
@@ -43,6 +43,13 @@ def as_shap_predictor(model: Any) -> Callable:
     interface for ``model``. The only thing lost is the suppression of a
     cosmetic scikit-learn warning.
 
+    It routes to ``predict_prepared``, not to ``predict``. Callers hand SHAP a
+    background already moved into the model's feature space with
+    ``prepare_model_input``, and SHAP then queries the model with perturbed
+    copies of *that* matrix. Going through ``predict`` would run the model's
+    input preparation a second time over an already prepared matrix — and SHAP
+    passes plain arrays, which the preparation cannot consume at all.
+
     Parameters
     ----------
     model : Any
@@ -51,12 +58,12 @@ def as_shap_predictor(model: Any) -> Callable:
     Returns
     -------
     Callable
-        A one-argument function calling ``model.predict`` positionally, the
-        same way SHAP calls it today.
+        A one-argument function calling ``model.predict_prepared``
+        positionally, the same way SHAP calls it.
     """
 
     def predict(x):
-        return model.predict(x)
+        return model.predict_prepared(x)
 
     return predict
 

tests/back/explainers/test_shap_predictor_handover.py

@@ -16,12 +16,12 @@
 from DashAI.back.explainability.model_input import as_shap_predictor
 
 
-def test_the_wrapped_predictor_forwards_to_predict_positionally():
+def test_the_wrapped_predictor_forwards_to_predict_prepared_positionally():
     """SHAP calls the model with one positional argument; that must not change."""
     seen = {}
 
     class Model:
-        def predict(self, x):
+        def predict_prepared(self, x):
             seen["arg"] = x
             return [0]
 
@@ -30,15 +30,34 @@ def predict(self, x):
     assert seen["arg"] == "the frame"
 
 
+def test_the_wrapped_predictor_never_routes_through_predict():
+    """The callers hand SHAP a background already in the model's feature space.
+
+    Routing to ``predict`` would prepare an already prepared matrix a second
+    time, and SHAP perturbs it into plain arrays that the preparation cannot
+    consume at all — which surfaces far away, as
+    ``'numpy.ndarray' object has no attribute 'types'``.
+    """
+
+    class Model:
+        def predict(self, x):
+            raise AssertionError("predict would prepare an already prepared matrix")
+
+        def predict_prepared(self, x):
+            return [1]
+
+    assert as_shap_predictor(Model())("the frame") == [1]
+
+
 def test_the_wrapped_predictor_hides_the_model_from_shap():
     """The whole mechanism: no ``__self__`` means SHAP never reaches the model."""
 
     class Model:
-        def predict(self, x):
+        def predict_prepared(self, x):
             return [0]
 
     model = Model()
-    assert getattr(model.predict, "__self__", None) is model
+    assert getattr(model.predict_prepared, "__self__", None) is model
     assert getattr(as_shap_predictor(model), "__self__", None) is None
 
 
@@ -53,15 +72,15 @@ class ReadOnlyFeatureNames:
         def feature_names_in_(self):
             return ["a", "b"]
 
-        def predict(self, x):
+        def predict_prepared(self, x):
             return [0]
 
     model = ReadOnlyFeatureNames()
 
     # The failure this exists to prevent: SHAP reaches the model through
     # ``__self__`` and tries to blank the attribute.
     with pytest.raises(AttributeError, match="feature_names_in_"):
-        convert_to_model(model.predict)
+        convert_to_model(model.predict_prepared)
 
     converted = convert_to_model(as_shap_predictor(model))