Add initial SHAP support

Author: ruivieira

tests/test_limeexplainer.py

@@ -5,7 +5,6 @@
 
 import pytest
 
-from common import mock_feature
 from trustyai.explainers import LimeExplainer
 from trustyai.local.counterfactual import simple_prediction
 from trustyai.utils import TestUtils

tests/test_shap.py

@@ -0,0 +1,35 @@
+# pylint: disable=import-error, wrong-import-position, wrong-import-order, duplicate-code
+"""SHAP explainer test suite"""
+
+from common import *
+
+import pytest
+
+from trustyai.explainers import SHAPExplainer
+from trustyai.local.counterfactual import simple_prediction
+from trustyai.model import feature, PredictionInput
+from trustyai.utils import TestUtils
+
+
+def test_no_variance_one_output():
+    """Check if the explanation returned is not null"""
+    model = TestUtils.getSumSkipModel(0)
+
+    background = [PredictionInput([feature(name="f", value=value, dtype="number") for value in [1.0, 2.0, 3.0]]) for _
+                  in
+                  range(2)]
+
+    prediction_outputs = model.predictAsync(background).get()
+
+    predictions = [simple_prediction(input_features=background[i].features, outputs=prediction_outputs[i].outputs) for i
+                   in
+                   range(2)]
+
+    shap_explainer = SHAPExplainer(background=background)
+
+    explanations = [shap_explainer.explain(prediction, model) for prediction in predictions]
+
+    for explanation in explanations:
+        for saliency in explanation.getSaliencies():
+            for feature_importance in saliency.getPerFeatureImportance():
+                assert feature_importance.getScore() == 0.0

trustyai/explainers.py

@@ -1,7 +1,8 @@
 """Explainers module"""
 # pylint: disable = import-error, too-few-public-methods
-from typing import Dict
+from typing import Dict, Optional, List
 
+from jpype import JInt
 from org.kie.kogito.explainability.local.counterfactual import (
     CounterfactualExplainer as _CounterfactualExplainer,
     CounterfactualResult,
@@ -13,11 +14,18 @@
     LimeExplainer as _LimeExplainer,
 )
 
+from org.kie.kogito.explainability.local.shap import (
+    ShapConfig as _ShapConfig,
+    ShapResults,
+    ShapKernelExplainer as _ShapKernelExplainer,
+)
+
 from org.kie.kogito.explainability.model import (
     CounterfactualPrediction,
     PredictionProvider,
     Saliency,
     PerturbationContext,
+    PredictionInput as _PredictionInput,
 )
 from org.optaplanner.core.config.solver.termination import TerminationConfig
 from java.lang import Long
@@ -37,15 +45,15 @@ def __init__(self, steps=10_000):
         )
         self._solver_config = (
             SolverConfigBuilder.builder()
-                .withTerminationConfig(self._termination_config)
-                .build()
+            .withTerminationConfig(self._termination_config)
+            .build()
         )
         self._cf_config = CounterfactualConfig().withSolverConfig(self._solver_config)
 
         self._explainer = _CounterfactualExplainer(self._cf_config)
 
     def explain(
-            self, prediction: CounterfactualPrediction, model: PredictionProvider
+        self, prediction: CounterfactualPrediction, model: PredictionProvider
     ) -> CounterfactualResult:
         """Request for a counterfactual explanation given a prediction and a model"""
         return self._explainer.explainAsync(prediction, model).get()
@@ -56,23 +64,23 @@ class LimeExplainer:
     """Wrapper for TrustyAI's LIME explainer"""
 
     def __init__(
-            self,
-            perturbations=1,
-            seed=0,
-            samples=10,
-            penalise_sparse_balance=True,
-            normalise_weights=True,
+        self,
+        perturbations=1,
+        seed=0,
+        samples=10,
+        penalise_sparse_balance=True,
+        normalise_weights=True,
     ):
         # build LIME configuration
         self._jrandom = Random()
         self._jrandom.setSeed(seed)
 
         self._lime_config = (
             LimeConfig()
-                .withNormalizeWeights(normalise_weights)
-                .withPerturbationContext(PerturbationContext(self._jrandom, perturbations))
-                .withSamples(samples)
-                .withPenalizeBalanceSparse(penalise_sparse_balance)
+            .withNormalizeWeights(normalise_weights)
+            .withPerturbationContext(PerturbationContext(self._jrandom, perturbations))
+            .withSamples(samples)
+            .withPenalizeBalanceSparse(penalise_sparse_balance)
         )
 
         self._explainer = _LimeExplainer(self._lime_config)
@@ -85,5 +93,29 @@ def explain(self, prediction, model: PredictionProvider) -> Dict[str, Saliency]:
 class SHAPExplainer:
     """Wrapper for TrustyAI's SHAP explainer"""
 
-    def __init__(self):
-        pass
+    def __init__(
+        self,
+        background: List[_PredictionInput],
+        samples=100,
+        seed=0,
+        perturbations=0,
+        link_type: Optional[_ShapConfig.LinkType] = None,
+    ):
+        if not link_type:
+            link_type = _ShapConfig.LinkType.IDENTITY
+        self._jrandom = Random()
+        self._jrandom.setSeed(seed)
+        perturbation_context = PerturbationContext(self._jrandom, perturbations)
+        self._config = (
+            _ShapConfig.builder()
+            .withLink(link_type)
+            .withPC(perturbation_context)
+            .withBackground(background)
+            .withNSamples(JInt(samples))
+            .build()
+        )
+        self._explainer = _ShapKernelExplainer(self._config)
+
+    def explain(self, prediction, model: PredictionProvider) -> List[ShapResults]:
+        """Request for a SHAP explanation given a prediction and a model"""
+        return self._explainer.explainAsync(prediction, model).get()