Merge branch 'master' into dependabot/pip/sphinx-gte-4.2.0-and-lt-7.0.0

Author: Ashley Scillitoe

.github/workflows/ci.yml

@@ -83,9 +83,12 @@ jobs:
           pytest -m "not tf1" alibi
 
       - name: Upload coverage to Codecov
-        if: ${{ success() }}
-        run: |
-          codecov -F ${{ matrix.os }}-${{ matrix.python-version }}
+        uses: codecov/codecov-action@v3
+        with:
+          directory: .
+          env_vars: ${{matrix.os}}, ${{matrix.python-version}}
+          fail_ci_if_error: false
+          verbose: true
 
       - name: Build Python package
         run: |

alibi/explainers/anchors/anchor_tabular.py

@@ -912,9 +912,10 @@ def add_names_to_exp(self, explanation: dict) -> None:
         """
 
         anchor_idxs = explanation['feature']
-        explanation['names'] = []
-        explanation['feature'] = [self.enc2feat_idx[idx] for idx in anchor_idxs]
         ordinal_ranges = {self.enc2feat_idx[idx]: [float('-inf'), float('inf')] for idx in anchor_idxs}
+        explanation['feature'] = list(ordinal_ranges.keys())
+        explanation['names'] = []
+
         for idx in set(anchor_idxs) - self.cat_lookup.keys():
             feat_id = self.enc2feat_idx[idx]  # feature col. id
             if 0 in self.ord_lookup[idx]:  # tells if the feature in X falls in a higher or lower bin

alibi/explainers/partial_dependence.py

@@ -506,6 +506,17 @@ def _build_explanation(self,
         )
         return Explanation(meta=copy.deepcopy(self.meta), data=data)
 
+    def reset_predictor(self, predictor: Union[Callable[[np.ndarray], np.ndarray], BaseEstimator]) -> None:
+        """
+        Resets the predictor function or tree-based `sklearn` estimator.
+
+        Parameters
+        ----------
+        predictor
+            New predictor function or tree-based `sklearn` estimator.
+        """
+        self.predictor = predictor
+
 
 class PartialDependence(PartialDependenceBase):
     """ Black-box implementation of partial dependence for tabular datasets.

alibi/explainers/similarity/backends/__init__.py

@@ -1,14 +1,16 @@
-from typing import Union, Type
+from typing import Type, Union
 
-from alibi.utils.frameworks import has_pytorch, has_tensorflow, Framework
+from alibi.utils.frameworks import Framework, has_pytorch, has_tensorflow
 
 if has_pytorch:
     # import pytorch backend
-    from alibi.explainers.similarity.backends.pytorch.base import _PytorchBackend
+    from alibi.explainers.similarity.backends.pytorch.base import \
+        _PytorchBackend
 
 if has_tensorflow:
     # import tensorflow backend
-    from alibi.explainers.similarity.backends.tensorflow.base import _TensorFlowBackend
+    from alibi.explainers.similarity.backends.tensorflow.base import \
+        _TensorFlowBackend
 
 
 def _select_backend(backend: Framework = Framework.TENSORFLOW) \

alibi/explainers/similarity/backends/pytorch/base.py

@@ -4,11 +4,11 @@
 backend in order to ensure that the similarity methods only require to match this interface.
 """
 
-from typing import Callable, Union, Optional
+from typing import Any, Callable, List, Optional, Union
 
 import numpy as np
-import torch.nn as nn
 import torch
+import torch.nn as nn
 
 
 class _PytorchBackend:
@@ -17,7 +17,7 @@ class _PytorchBackend:
     @staticmethod
     def get_grads(
             model: nn.Module,
-            X: torch.Tensor,
+            X: Union[torch.Tensor, List[Any]],
             Y: torch.Tensor,
             loss_fn: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
     ) -> np.ndarray:

alibi/explainers/similarity/backends/tensorflow/base.py

@@ -4,7 +4,7 @@
 backend in order to ensure that the similarity methods only require to match this interface.
 """
 
-from typing import Callable, Optional, Union
+from typing import Any, Callable, List, Optional, Union
 
 import numpy as np
 import tensorflow as tf
@@ -17,7 +17,7 @@ class _TensorFlowBackend:
     @staticmethod
     def get_grads(
             model: keras.Model,
-            X: tf.Tensor,
+            X: Union[tf.Tensor, List[Any]],
             Y: tf.Tensor,
             loss_fn: Callable[[tf.Tensor, tf.Tensor], tf.Tensor],
     ) -> np.ndarray:

alibi/explainers/similarity/base.py

@@ -1,13 +1,16 @@
 from abc import ABC
-from typing import TYPE_CHECKING, Callable, Union, Tuple, Optional
-from typing_extensions import Literal
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
 
 import numpy as np
-from tqdm import tqdm
-
 from alibi.api.interfaces import Explainer
 from alibi.explainers.similarity.backends import _select_backend
-from alibi.utils.frameworks import Framework
+from alibi.utils.frameworks import Framework, has_pytorch, has_tensorflow
+from alibi.utils.missing_optional_dependency import import_optional
+from tqdm import tqdm
+from typing_extensions import Literal
+
+_TfTensor = import_optional('tensorflow', ['Tensor'])
+_PtTensor = import_optional('torch', ['Tensor'])
 
 if TYPE_CHECKING:
     import tensorflow
@@ -63,7 +66,7 @@ def __init__(self,
         super().__init__(meta=meta)
 
     def fit(self,
-            X_train: np.ndarray,
+            X_train: Union[np.ndarray, List[Any]],
             Y_train: np.ndarray) -> "Explainer":
         """Fit the explainer. If ``self.precompute_grads == True`` then the gradients are precomputed and stored.
 
@@ -79,21 +82,42 @@ def fit(self,
         self
             Returns self.
         """
-        self.X_train: np.ndarray = X_train
-        self.Y_train: np.ndarray = Y_train
-        self.X_dims: Tuple = self.X_train.shape[1:]
-        self.Y_dims: Tuple = self.Y_train.shape[1:]
-        self.grad_X_train: np.ndarray = np.array([])
+        self.X_train = X_train
+        self.Y_train = Y_train
+        self.X_dims = self.X_train.shape[1:] if isinstance(self.X_train, np.ndarray) else None
+        self.Y_dims = self.Y_train.shape[1:]
+        self.grad_X_train = np.array([])
 
         # compute and store gradients
         if self.precompute_grads:
             grads = []
+            X: Union[np.ndarray, List[Any]]
             for X, Y in tqdm(zip(self.X_train, self.Y_train), disable=not self.verbose):
-                grad_X_train = self._compute_grad(X[None], Y[None])
+                grad_X_train = self._compute_grad(self._format(X), Y[None])
                 grads.append(grad_X_train[None])
+
             self.grad_X_train = np.concatenate(grads, axis=0)
         return self
 
+    @staticmethod
+    def _is_tensor(x: Any) -> bool:
+        """Checks if an obejct is a tensor."""
+        if has_tensorflow and isinstance(x, _TfTensor):
+            return True
+        if has_pytorch and isinstance(x, _PtTensor):
+            return True
+        if isinstance(x, np.ndarray):
+            return True
+        return False
+
+    @staticmethod
+    def _format(x: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, Any]'
+                ) -> 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, List[Any]]':
+        """Adds batch dimension."""
+        if BaseSimilarityExplainer._is_tensor(x):
+            return x[None]
+        return [x]
+
     def _verify_fit(self) -> None:
         """Verify that the explainer has been fitted.
 
@@ -102,14 +126,15 @@ def _verify_fit(self) -> None:
         ValueError
             If the explainer has not been fitted.
         """
-
         if not hasattr(self, 'X_train') or not hasattr(self, 'Y_train'):
             raise ValueError('Training data not set. Call `fit` and pass training data first.')
 
     def _match_shape_to_data(self,
-                             data: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]',
-                             target_type: Literal['X', 'Y']) -> 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]':
-        """Verify the shape of `data` against the shape of the training data.
+                             data: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, Any, List[Any]]',
+                             target_type: Literal['X', 'Y']
+                             ) -> 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, List[Any]]':
+        """
+        Verify the shape of `data` against the shape of the training data.
 
         Used to ensure input is correct shape for gradient methods implemented in the backends. `data` will be the
         features or label of the instance being explained. If the `data` is not a batch, reshape to be a single batch
@@ -131,6 +156,15 @@ def _match_shape_to_data(self,
             If the shape of `data` does not match the shape of the training data, or fit has not been called prior to
             calling this method.
         """
+        if self._is_tensor(data):
+            return self._match_shape_to_data_tensor(data, target_type)
+        return self._match_shape_to_data_any(data)
+
+    def _match_shape_to_data_tensor(self,
+                                    data: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]',
+                                    target_type: Literal['X', 'Y']
+                                    ) -> 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]':
+        """ Verify the shape of `data` against the shape of the training data for tensor like data."""
         target_shape = getattr(self, f'{target_type}_dims')
         if data.shape == target_shape:
             data = data[None]
@@ -139,6 +173,13 @@ def _match_shape_to_data(self,
                               f' but training data has shape {target_shape}'))
         return data
 
+    @staticmethod
+    def _match_shape_to_data_any(data: Union[Any, List[Any]]) -> list:
+        """ Ensures that any other data type is a list."""
+        if isinstance(data, list):
+            return data
+        return [data]
+
     def _compute_adhoc_similarity(self, grad_X: np.ndarray) -> np.ndarray:
         """
         Computes the similarity between the gradients of the test instances and all the training instances. The method
@@ -149,18 +190,18 @@ def _compute_adhoc_similarity(self, grad_X: np.ndarray) -> np.ndarray:
         grad_X
             Gradients of the test instances.
         """
-        scores = np.zeros((grad_X.shape[0], self.X_train.shape[0]))
+        scores = np.zeros((len(grad_X), len(self.X_train)))
+        X: Union[np.ndarray, List[Any]]
         for i, (X, Y) in tqdm(enumerate(zip(self.X_train, self.Y_train)), disable=not self.verbose):
-            grad_X_train = self._compute_grad(X[None], Y[None])
+            grad_X_train = self._compute_grad(self._format(X), Y[None])
             scores[:, i] = self.sim_fn(grad_X, grad_X_train[None])[:, 0]
         return scores
 
     def _compute_grad(self,
-                      X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]',
+                      X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, List[Any]]',
                       Y: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]') \
             -> np.ndarray:
         """Computes predictor parameter gradients and returns a flattened `numpy` array."""
-
         X = self.backend.to_tensor(X) if isinstance(X, np.ndarray) else X
         Y = self.backend.to_tensor(Y) if isinstance(Y, np.ndarray) else Y
         return self.backend.get_grads(self.predictor, X, Y, self.loss_fn)

alibi/explainers/similarity/grad.py

@@ -4,20 +4,19 @@
 """
 
 import copy
-from typing import TYPE_CHECKING, Callable, Optional, Union, Dict, Tuple
-from typing_extensions import Literal
-from enum import Enum
 import warnings
+from enum import Enum
+from typing import (TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple,
+                    Union)
 
 import numpy as np
-
-from alibi.api.interfaces import Explanation
+from alibi.api.defaults import DEFAULT_DATA_SIM, DEFAULT_META_SIM
+from alibi.api.interfaces import Explainer, Explanation
 from alibi.explainers.similarity.base import BaseSimilarityExplainer
-from alibi.explainers.similarity.metrics import dot, cos, asym_dot
-from alibi.api.defaults import DEFAULT_META_SIM, DEFAULT_DATA_SIM
+from alibi.explainers.similarity.metrics import asym_dot, cos, dot
 from alibi.utils import _get_options_string
 from alibi.utils.frameworks import Framework
-from alibi.api.interfaces import Explainer
+from typing_extensions import Literal
 
 if TYPE_CHECKING:
     import tensorflow
@@ -140,7 +139,7 @@ def __init__(self,
             warnings.warn(warning_msg)
 
     def fit(self,
-            X_train: np.ndarray,
+            X_train: Union[np.ndarray, List[Any]],
             Y_train: np.ndarray) -> "Explainer":
         """Fit the explainer.
 
@@ -165,7 +164,7 @@ def fit(self,
 
     def _preprocess_args(
             self,
-            X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]',
+            X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, Any, List[Any]]',
             Y: 'Optional[Union[np.ndarray, tensorflow.Tensor, torch.Tensor]]' = None) \
             -> 'Union[Tuple[torch.Tensor, torch.Tensor], Tuple[tensorflow.Tensor, tensorflow.Tensor]]':
         """Formats `X`, `Y` for explain method.
@@ -205,7 +204,7 @@ def _preprocess_args(
 
     def explain(
             self,
-            X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor]',
+            X: 'Union[np.ndarray, tensorflow.Tensor, torch.Tensor, Any, List[Any]]',
             Y: 'Optional[Union[np.ndarray, tensorflow.Tensor, torch.Tensor]]' = None) -> "Explanation":
         """Explain the predictor's predictions for a given input.
 
@@ -217,8 +216,9 @@ def explain(
         Parameters
         ----------
         X
-            `X` can be a `numpy` array, `tensorflow` tensor, or `pytorch` tensor of the same shape as the training data
-            with or without a leading batch dimension. If the batch dimension is missing it's added.
+            `X` can be a `numpy` array, `tensorflow` tensor, `pytorch` tensor of the same shape as the training data
+            or a list of objects, with or without a leading batch dimension. If the batch dimension is missing it's
+            added.
         Y
             `Y` can be a `numpy` array, `tensorflow` tensor or a `pytorch` tensor. In the case of a regression task, the
             `Y` argument must be present. If the task is classification then `Y` defaults to the model prediction.
@@ -249,7 +249,7 @@ def explain(
         X, Y = self._preprocess_args(X, Y)
         test_grads = []
         for x, y in zip(X, Y):
-            test_grads.append(self._compute_grad(x[None], y[None])[None])
+            test_grads.append(self._compute_grad(self._format(x), y[None])[None])
         grads_X_test = np.concatenate(np.array(test_grads), axis=0)
         if not self.precompute_grads:
             scores = self._compute_adhoc_similarity(grads_X_test)
@@ -267,11 +267,24 @@ def _build_explanation(self, scores: np.ndarray) -> "Explanation":
         """
         data = copy.deepcopy(DEFAULT_DATA_SIM)
         sorted_score_indices = np.argsort(scores)[:, ::-1]
-        broadcast_indices = np.expand_dims(sorted_score_indices, axis=tuple(range(2, len(self.X_train[None].shape))))
+        most_similar: Union[np.ndarray, List[Any]]
+        least_similar: Union[np.ndarray, List[Any]]
+
+        if isinstance(self.X_train, np.ndarray):
+            broadcast_indices = np.expand_dims(
+                sorted_score_indices,
+                axis=tuple(range(2, len(self.X_train[None].shape)))
+            )
+            most_similar = np.take_along_axis(self.X_train[None], broadcast_indices[:, :5], axis=1)
+            least_similar = np.take_along_axis(self.X_train[None], broadcast_indices[:, -1:-6:-1], axis=1)
+        else:
+            most_similar = [[self.X_train[i] for i in ssi[:5]] for ssi in sorted_score_indices]
+            least_similar = [[self.X_train[i] for i in ssi[-1:-6:-1]] for ssi in sorted_score_indices]
+
         data.update(
             scores=np.take_along_axis(scores, sorted_score_indices, axis=1),
             ordered_indices=sorted_score_indices,
-            most_similar=np.take_along_axis(self.X_train[None], broadcast_indices[:, :5], axis=1),
-            least_similar=np.take_along_axis(self.X_train[None], broadcast_indices[:, -1:-6:-1], axis=1),
+            most_similar=most_similar,
+            least_similar=least_similar
         )
         return Explanation(meta=self.meta, data=data)

doc/source/examples/cem_iris.ipynb

@@ -448,7 +448,7 @@
     "pp['species'] = 'PP_' + class_names[expl['PP_pred']]\n",
     "orig_inst = pd.DataFrame(explanation.X, columns=dataset.feature_names)\n",
     "orig_inst['species'] = 'orig_' + class_names[explanation.X_pred]\n",
-    "df = df.append([pn, pp, orig_inst], ignore_index=True)"
+    "df = pd.concat([df, pn, pp, orig_inst], ignore_index=True)"
    ]
   },
   {
@@ -634,7 +634,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -648,7 +648,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.13"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,