Add LIME explanation plot

Author: ruivieira

requirements.txt

@@ -1 +1,2 @@
-JPype1==1.3.0
+JPype1==1.3.0
+matplotlib==3.5.1

trustyai/explainers.py

@@ -1,6 +1,7 @@
 """Explainers module"""
 # pylint: disable = import-error, too-few-public-methods
 from typing import Dict, Optional, List
+import matplotlib.pyplot as plt
 
 from jpype import JInt
 from org.kie.kogito.explainability.local.counterfactual import (
@@ -45,61 +46,89 @@ 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()
 
 
+class LimeExplanation:
+    """Encapsulate LIME results"""
+
+    def __init__(self, saliencies: Dict[str, Saliency]):
+        self._saliencies = saliencies
+
+    def show(self, decision: str) -> str:
+        """Return saliencies for a decision"""
+        result = f"Saliencies for '{decision}':\n"
+        for f in self._saliencies.get(decision).getPerFeatureImportance():
+            result += f'\t{f.getFeature().name}: {f.getScore()}\n'
+        return result
+
+    def map(self):
+        return self._saliencies
+
+    def plot(self, decision: str):
+        d = {}
+        for f in self._saliencies.get(decision).getPerFeatureImportance():
+            d[f.getFeature().name] = f.getScore()
+
+        colours = ['r' if i < 0 else 'g' for i in d.values()]
+        plt.title(f"LIME explanation for '{decision}'")
+        plt.barh(range(len(d)), d.values(), align='center', color=colours)
+        plt.yticks(range(len(d)), list(d.keys()))
+        plt.tight_layout()
+
+
 # pylint: disable=too-many-arguments
 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)
 
-    def explain(self, prediction, model: PredictionProvider) -> Dict[str, Saliency]:
+    def explain(self, prediction, model: PredictionProvider) -> LimeExplanation:
         """Request for a LIME explanation given a prediction and a model"""
-        return self._explainer.explainAsync(prediction, model).get()
+        return LimeExplanation(self._explainer.explainAsync(prediction, model).get())
 
 
 class SHAPExplainer:
     """Wrapper for TrustyAI's SHAP explainer"""
 
     def __init__(
-        self,
-        background: List[_PredictionInput],
-        samples=100,
-        seed=0,
-        perturbations=0,
-        link_type: Optional[_ShapConfig.LinkType] = None,
+            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
@@ -108,11 +137,11 @@ def __init__(
         perturbation_context = PerturbationContext(self._jrandom, perturbations)
         self._config = (
             _ShapConfig.builder()
-            .withLink(link_type)
-            .withPC(perturbation_context)
-            .withBackground(background)
-            .withNSamples(JInt(samples))
-            .build()
+                .withLink(link_type)
+                .withPC(perturbation_context)
+                .withBackground(background)
+                .withNSamples(JInt(samples))
+                .build()
         )
         self._explainer = _ShapKernelExplainer(self._config)