diff --git a/molpipeline/explainability/__init__.py b/molpipeline/explainability/__init__.py new file mode 100644 index 00000000..0d934450 --- /dev/null +++ b/molpipeline/explainability/__init__.py @@ -0,0 +1,19 @@ +"""Explainability module for the molpipeline package.""" + +from molpipeline.explainability.explainer import SHAPTreeExplainer +from molpipeline.explainability.explanation import ( + SHAPFeatureAndAtomExplanation, + SHAPFeatureExplanation, +) +from molpipeline.explainability.visualization.visualization import ( + structure_heatmap, + structure_heatmap_shap, +) + +__all__ = [ + "SHAPFeatureExplanation", + "SHAPFeatureAndAtomExplanation", + "SHAPTreeExplainer", + "structure_heatmap", + "structure_heatmap_shap", +] diff --git a/molpipeline/explainability/explainer.py b/molpipeline/explainability/explainer.py new file mode 100644 index 00000000..0323c42b --- /dev/null +++ b/molpipeline/explainability/explainer.py @@ -0,0 +1,467 @@ +"""Explainer classes for explaining predictions.""" + +from __future__ import annotations + +import abc +from typing import Any, TypeAlias + +import numpy as np +import numpy.typing as npt +import pandas as pd +import shap +from scipy.sparse import issparse, spmatrix +from sklearn.base import BaseEstimator +from typing_extensions import override + +from molpipeline import Pipeline +from molpipeline.abstract_pipeline_elements.core import OptionalMol +from molpipeline.explainability.explanation import ( + AtomExplanationMixin, + BondExplanationMixin, + FeatureExplanationMixin, + FeatureInfoMixin, + SHAPExplanationMixin, + SHAPFeatureAndAtomExplanation, + SHAPFeatureExplanation, +) +from molpipeline.explainability.fingerprint_utils import fingerprint_shap_to_atomweights +from molpipeline.mol2any import MolToMorganFP +from molpipeline.utils.subpipeline import SubpipelineExtractor, get_model_from_pipeline + + +# pylint: disable=C0103,W0613 +def _to_dense( + feature_matrix: npt.NDArray[Any] | spmatrix, +) -> npt.NDArray[Any]: + """Mitigate feature incompatibility with SHAP objects. + + Parameters + ---------- + feature_matrix : npt.NDArray[Any] | spmatrix + The input features. + + Returns + ------- + Any + The input features in a compatible format. + """ + if issparse(feature_matrix): + return feature_matrix.todense() # type: ignore[union-attr] + return feature_matrix + + +def _convert_to_array(value: Any) -> npt.NDArray[np.float64]: + """Convert a value to a numpy array. + + Parameters + ---------- + value : Any + The value to convert. + + Returns + ------- + npt.NDArray[np.float64] + The value as a numpy array. + """ + if isinstance(value, np.ndarray): + return value + if np.isscalar(value): + return np.array([value]) + raise ValueError("Value is not a scalar or numpy array.") + + +def _get_prediction_function(pipeline: Pipeline | BaseEstimator) -> Any: + """Get the prediction function of a model. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model. + + Returns + ------- + Any + The prediction function. + """ + if hasattr(pipeline, "predict_proba"): + return pipeline.predict_proba + if hasattr(pipeline, "decision_function"): + return pipeline.decision_function + if hasattr(pipeline, "predict"): + return pipeline.predict + raise ValueError("Could not determine the model output predictions") + + +# This function might also be put at a more central position in the lib. +def _get_predictions( + pipeline: Pipeline, feature_matrix: npt.NDArray[Any] | spmatrix +) -> npt.NDArray[np.float64]: + """Get the predictions of a model. + + Raises if no adequate method is found. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model. + feature_matrix : Any + The input data. + + Returns + ------- + npt.NDArray[np.float64] + The predictions. + """ + prediction_function = _get_prediction_function(pipeline) + prediction = prediction_function(feature_matrix) + return np.array(prediction) + + +def _convert_shap_feature_weights_to_atom_weights( + feature_weights: npt.NDArray[np.float64], + molecule: OptionalMol, + featurization_element: MolToMorganFP, + feature_vector: npt.NDArray[np.float64], +) -> npt.NDArray[np.float64]: + """Convert SHAP feature weights to atom weights. + + Parameters + ---------- + feature_weights : npt.NDArray[np.float64] + The feature weights. + molecule : OptionalMol + The molecule. + featurization_element : MolToMorganFP + The featurization element. + feature_vector : npt.NDArray[np.float64] + The feature vector. + + Returns + ------- + npt.NDArray[np.float64] + The atom weights. + """ + if feature_weights.ndim == 1: + # regression case + feature_weights_present_bits_only = feature_weights.copy() + elif feature_weights.ndim == 2: + # binary classification case. Take the weights for the positive class. + feature_weights_present_bits_only = feature_weights[:, 1].copy() + else: + raise ValueError( + "Unsupported number of dimensions for feature weights. Expected 1 or 2." + ) + + # reset shap values for bits that are not present in the molecule + feature_weights_present_bits_only[feature_vector == 0] = 0 + + atom_weights = np.array( + fingerprint_shap_to_atomweights( + molecule, + featurization_element, + feature_weights_present_bits_only, + ) + ) + return atom_weights + + +_SHAPExplainer_return_type_: TypeAlias = list[ + SHAPFeatureExplanation | SHAPFeatureAndAtomExplanation +] + + +# pylint: disable=R0903 +class AbstractSHAPExplainer(abc.ABC): + """Abstract class for SHAP explainer objects.""" + + # pylint: disable=C0103,W0613 + @abc.abstractmethod + def explain(self, X: Any, **kwargs: Any) -> _SHAPExplainer_return_type_: + """Explain the predictions for the input data. + + Parameters + ---------- + X : Any + The input data to explain. + kwargs : Any + Additional keyword arguments. + + Returns + ------- + list[SHAPFeatureExplanation | SHAPFeatureAndAtomExplanation] + List of explanations corresponding to the input samples. + """ + + +# pylint: disable=R0903 +class SHAPExplainerAdapter(AbstractSHAPExplainer, abc.ABC): + """Adapter for SHAP explainer wrappers for handling molecules and pipelines.""" + + def __init__( + self, + pipeline: Pipeline, + explainer: shap.TreeExplainer | shap.KernelExplainer, + **kwargs: Any, + ) -> None: + """Initialize the SHAPTreeExplainer. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model to explain. + explainer : shap.TreeExplainer | shap.KernelExplainer + The shap explainer object. + kwargs : Any + Additional keyword arguments for SHAP's TreeExplainer. + """ + self.pipeline = pipeline + self.explainer = explainer + + pipeline_extractor = SubpipelineExtractor(self.pipeline) + + # extract the molecule reader subpipeline + self.molecule_reader_subpipeline = ( + pipeline_extractor.get_molecule_reader_subpipeline() + ) + if self.molecule_reader_subpipeline is None: + raise ValueError("Could not determine the molecule reader subpipeline.") + + # extract the featurization subpipeline + self.featurization_subpipeline = ( + pipeline_extractor.get_featurization_subpipeline() + ) + if self.featurization_subpipeline is None: + raise ValueError("Could not determine the featurization subpipeline.") + + # determine type of returned explanation + featurization_element = self.featurization_subpipeline.steps[-1][1] # type: ignore[union-attr] + self.return_element_type_: type[ + SHAPFeatureExplanation | SHAPFeatureAndAtomExplanation + ] + if isinstance(featurization_element, MolToMorganFP): + self.return_element_type_ = SHAPFeatureAndAtomExplanation + else: + self.return_element_type_ = SHAPFeatureExplanation + + @staticmethod + def _prediction_is_valid(prediction: Any) -> bool: + """Check if the prediction is valid using some heuristics. + + Can be used to catch inputs that failed the pipeline for some reason. + + Parameters + ---------- + prediction : Any + The prediction. + Returns + ------- + bool + Whether the prediction is valid. + """ + # if no prediction could be obtained (length is 0); the prediction guaranteed failed. + if len(prediction) == 0: + return False + + # use pandas.isna function to check for invalid predictions, e.g. None, np.nan, + # pd.NA. Note that fill values like 0 will be considered as valid predictions. + if pd.isna(prediction).any(): + return False + + return True + + # pylint: disable=C0103,W0613 + @override + def explain(self, X: Any, **kwargs: Any) -> _SHAPExplainer_return_type_: + """Explain the predictions for the input data. + + If the calculation of the SHAP values for an input sample fails, the explanation will be invalid. + This can be checked with the Explanation.is_valid() method. + + Parameters + ---------- + X : Any + The input data to explain. + kwargs : Any + Additional keyword arguments for SHAP's TreeExplainer.shap_values. + + Returns + ------- + list[SHAPFeatureExplanation | SHAPFeatureAndAtomExplanation] + List of explanations corresponding to the input data. + """ + featurization_element = self.featurization_subpipeline.steps[-1][1] # type: ignore[union-attr] + + explanation_results: _SHAPExplainer_return_type_ = [] + for input_sample in X: + + input_sample = [input_sample] + + # get predictions + prediction = _get_predictions(self.pipeline, input_sample) + if not self._prediction_is_valid(prediction): + # we use the prediction to check if the input is valid. If not, we cannot explain it. + explanation_results.append(self.return_element_type_()) + continue + + if prediction.ndim > 1: + prediction = prediction.squeeze() + + # get the molecule + molecule = self.molecule_reader_subpipeline.transform(input_sample)[0] # type: ignore[union-attr] + + # get feature vectors + feature_vector = self.featurization_subpipeline.transform(input_sample) # type: ignore[union-attr] + feature_vector = _to_dense(feature_vector) + feature_vector = np.asarray(feature_vector).squeeze() + + if feature_vector.size == 0: + # if the feature vector is empty, we cannot explain the prediction. + # This happens for failed instances in pipeline with fill values + # that could be valid predictions, like 0. + explanation_results.append(self.return_element_type_()) + continue + + # compute the shap values for the features + feature_weights = self.explainer.shap_values(feature_vector, **kwargs) + feature_weights = np.asarray(feature_weights).squeeze() + + atom_weights = None + bond_weights = None + + if issubclass( + self.return_element_type_, AtomExplanationMixin + ) and isinstance(featurization_element, MolToMorganFP): + # for Morgan fingerprint, we can map the shap values to atom weights + atom_weights = _convert_shap_feature_weights_to_atom_weights( + feature_weights, + molecule, + featurization_element, + feature_vector, + ) + + # gather all input data for the explanation type to be returned + explanation_data = { + "molecule": molecule, + "prediction": prediction, + } + if issubclass(self.return_element_type_, FeatureInfoMixin): + explanation_data["feature_vector"] = feature_vector + if not hasattr(featurization_element, "feature_names"): + raise ValueError( + "Featurization element does not have a get_feature_names method." + ) + explanation_data["feature_names"] = featurization_element.feature_names # type: ignore[union-attr] + + if issubclass(self.return_element_type_, FeatureExplanationMixin): + explanation_data["feature_weights"] = feature_weights + if issubclass(self.return_element_type_, AtomExplanationMixin): + explanation_data["atom_weights"] = atom_weights + if issubclass(self.return_element_type_, BondExplanationMixin): + explanation_data["bond_weights"] = bond_weights + if issubclass(self.return_element_type_, SHAPExplanationMixin): + explanation_data["expected_value"] = _convert_to_array( + self.explainer.expected_value + ) + + explanation_results.append(self.return_element_type_(**explanation_data)) + + return explanation_results + + +class SHAPTreeExplainer(SHAPExplainerAdapter): + """Wrapper for SHAP's TreeExplainer that can handle pipelines and molecules. + + Wraps SHAP's TreeExplainer to explain predictions of a pipeline containing a + tree-based model. + + Note on failed instances: + SHAPTreeExplainer will automatically handle fill values for failed instances and + returns an invalid explanation for them. However, fill values that could be valid + predictions, e.g. 0, are not necessarily detected. Set the fill value to np.nan or + None if these failed instances should not be explained. + """ + + def __init__( + self, + pipeline: Pipeline, + **kwargs: Any, + ) -> None: + """Initialize the SHAPKernelExplainer. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model to explain. + kwargs : Any + Additional keyword arguments for SHAP's Explainer. + """ + explainer = self._create_explainer(pipeline, **kwargs) + super().__init__(pipeline, explainer, **kwargs) + + @staticmethod + def _create_explainer(pipeline: Pipeline, **kwargs: Any) -> shap.TreeExplainer: + """Create the TreeExplainer object from shap. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model to explain. + kwargs : Any + Additional keyword arguments for the explainer. + + Returns + ------- + shap.TreeExplainer + The explainer object. + """ + model = get_model_from_pipeline(pipeline, raise_not_found=True) + explainer = shap.TreeExplainer( + model, + **kwargs, + ) + return explainer + + +class SHAPKernelExplainer(SHAPExplainerAdapter): + """Wrapper for SHAP's KernelExplainer that can handle pipelines and molecules.""" + + def __init__( + self, + pipeline: Pipeline, + **kwargs: Any, + ) -> None: + """Initialize the SHAPKernelExplainer. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model to explain. + kwargs : Any + Additional keyword arguments for SHAP's Explainer. + """ + explainer = self._create_explainer(pipeline, **kwargs) + super().__init__(pipeline, explainer, **kwargs) + + @staticmethod + def _create_explainer(pipeline: Pipeline, **kwargs: Any) -> shap.KernelExplainer: + """Create the explainer object. + + Parameters + ---------- + pipeline : Pipeline + The pipeline containing the model to explain. + kwargs : Any + Additional keyword arguments for the explainer. + + Returns + ------- + shap.KernelExplainer + The explainer object. + """ + model = get_model_from_pipeline(pipeline, raise_not_found=True) + prediction_function = _get_prediction_function(model) + explainer = shap.KernelExplainer( + prediction_function, + **kwargs, + ) + return explainer diff --git a/molpipeline/explainability/explanation.py b/molpipeline/explainability/explanation.py new file mode 100644 index 00000000..a945d2bf --- /dev/null +++ b/molpipeline/explainability/explanation.py @@ -0,0 +1,116 @@ +"""Module for explanation class.""" + +from __future__ import annotations + +import abc +import dataclasses + +import numpy as np +import numpy.typing as npt + +from molpipeline.abstract_pipeline_elements.core import RDKitMol + + +@dataclasses.dataclass(kw_only=True) +class _AbstractMoleculeExplanation(abc.ABC): + """Abstract class representing an explanation for a prediction for a molecule.""" + + molecule: RDKitMol | None = None + prediction: npt.NDArray[np.float64] | None = None + + +@dataclasses.dataclass(kw_only=True) +class FeatureInfoMixin: + """Mixin providing additional information about the features used in the explanation.""" + + feature_vector: npt.NDArray[np.float64] | None = None + feature_names: list[str] | None = None + + +@dataclasses.dataclass(kw_only=True) +class FeatureExplanationMixin: + """Explanation based on feature importance scores, e.g. Shapley Values.""" + + # explanation scores for individual features + feature_weights: npt.NDArray[np.float64] | None = None + + +@dataclasses.dataclass(kw_only=True) +class AtomExplanationMixin: + """Atom score based explanation.""" + + # explanation scores for individual atoms + atom_weights: npt.NDArray[np.float64] | None = None + + +@dataclasses.dataclass(kw_only=True) +class BondExplanationMixin: + """Bond score based explanation.""" + + # explanation scores for individual bonds + bond_weights: npt.NDArray[np.float64] | None = None + + +@dataclasses.dataclass(kw_only=True) +class SHAPExplanationMixin: + """Mixin providing additional information only present in SHAP explanations.""" + + expected_value: npt.NDArray[np.float64] | None = None + + +@dataclasses.dataclass(kw_only=True) +class SHAPFeatureExplanation( + FeatureInfoMixin, + FeatureExplanationMixin, + SHAPExplanationMixin, + _AbstractMoleculeExplanation, # base-class should be the last element https://www.ianlewis.org/en/mixins-and-python +): + """Explanation using feature importance scores from SHAP.""" + + def is_valid(self) -> bool: + """Check if the explanation is valid. + + Returns + ------- + bool + True if the explanation is valid, False otherwise. + """ + return all( + [ + self.feature_vector is not None, + self.feature_names is not None, + self.molecule is not None, + self.prediction is not None, + self.feature_weights is not None, + ] + ) + + +@dataclasses.dataclass(kw_only=True) +class SHAPFeatureAndAtomExplanation( + FeatureInfoMixin, + FeatureExplanationMixin, + SHAPExplanationMixin, + AtomExplanationMixin, + _AbstractMoleculeExplanation, +): + """Explanation using feature and atom importance scores from SHAP.""" + + def is_valid(self) -> bool: + """Check if the explanation is valid. + + Returns + ------- + bool + True if the explanation is valid, False otherwise. + """ + return all( + [ + self.feature_vector is not None, + self.feature_names is not None, + self.molecule is not None, + self.prediction is not None, + self.feature_weights is not None, + self.atom_weights is not None, + ] + ) diff --git a/molpipeline/explainability/fingerprint_utils.py b/molpipeline/explainability/fingerprint_utils.py new file mode 100644 index 00000000..b10dd141 --- /dev/null +++ b/molpipeline/explainability/fingerprint_utils.py @@ -0,0 +1,83 @@ +"""Utility functions for explainability.""" + +from __future__ import annotations + +from collections import defaultdict +from typing import Sequence + +import numpy as np +import numpy.typing as npt + +from molpipeline.abstract_pipeline_elements.core import RDKitMol +from molpipeline.mol2any import MolToMorganFP +from molpipeline.utils.substructure_handling import AtomEnvironment + + +def assign_prediction_importance( + bit_dict: dict[int, Sequence[AtomEnvironment]], weights: npt.NDArray[np.float64] +) -> dict[int, float]: + """Assign the prediction importance. + + Originally from Christian W. Feldmann + https://github.com/c-feldmann/compchemkit/blob/64e5543e2b8f72e93711186b2e0b42366820fb52/compchemkit/molecular_heatmaps.py#L28 + + Parameters + ---------- + bit_dict : dict[int, Sequence[AtomEnvironment]] + The bit dictionary. + weights : npt.NDArray[np.float64] + The weights. + + Returns + ------- + dict[int, float] + The atom contribution. + """ + atom_contribution: dict[int, float] = defaultdict(lambda: 0) + for bit, atom_env_list in bit_dict.items(): # type: int, Sequence[AtomEnvironment] + n_machtes = len(atom_env_list) + for atom_set in atom_env_list: + for atom in atom_set.environment_atoms: + atom_contribution[atom] += weights[bit] / ( + len(atom_set.environment_atoms) * n_machtes + ) + if not np.isclose(sum(weights), sum(atom_contribution.values())).all(): + raise AssertionError( + f"Weights and atom contributions don't sum to the same value:" + f" {weights.sum()} != {sum(atom_contribution.values())}" + ) + return atom_contribution + + +def fingerprint_shap_to_atomweights( + mol: RDKitMol, fingerprint_element: MolToMorganFP, shap_mat: npt.NDArray[np.float64] +) -> list[float]: + """Convert SHAP values to atom weights. + + Originally from Christian W. Feldmann + https://github.com/c-feldmann/compchemkit/blob/64e5543e2b8f72e93711186b2e0b42366820fb52/compchemkit/molecular_heatmaps.py#L15 + + Parameters + ---------- + mol : RDKitMol + The molecule. + fingerprint_element : MolToMorganFP + The fingerprint element. + shap_mat : npt.NDArray[np.float64] + The SHAP values. + + Returns + ------- + list[float] + The atom weights. + """ + bit_atom_env_dict: dict[int, Sequence[AtomEnvironment]] + bit_atom_env_dict = dict( + fingerprint_element.bit2atom_mapping(mol) + ) # MyPy invariants make me do this. + atom_weight_dict = assign_prediction_importance(bit_atom_env_dict, shap_mat) + atom_weight_list = [ + atom_weight_dict[a_idx] if a_idx in atom_weight_dict else 0 + for a_idx in range(mol.GetNumAtoms()) + ] + return atom_weight_list diff --git a/molpipeline/explainability/visualization/__init__.py b/molpipeline/explainability/visualization/__init__.py new file mode 100644 index 00000000..7fbc38ac --- /dev/null +++ b/molpipeline/explainability/visualization/__init__.py @@ -0,0 +1 @@ +"""Visualization module for explainability.""" diff --git a/molpipeline/explainability/visualization/gauss.py b/molpipeline/explainability/visualization/gauss.py new file mode 100644 index 00000000..4652f273 --- /dev/null +++ b/molpipeline/explainability/visualization/gauss.py @@ -0,0 +1,72 @@ +"""Gaussian functions for visualization. + +Much of the visualization code in this file originates from projects of Christian W. Feldmann: + https://github.com/c-feldmann/rdkit_heatmaps + https://github.com/c-feldmann/compchemkit +""" + +import numpy as np +import numpy.typing as npt + + +# pylint: disable=too-few-public-methods +class GaussFunctor2D: + """2D Gaussian functor.""" + + def __init__( + self, + center: npt.NDArray[np.float64], + std1: float = 1, + std2: float = 1, + scale: float = 1, + rotation: float = 0, + ) -> None: + """Initialize 2D Gaussian functor. + + Parameters + ---------- + center: npt.NDArray[np.float64] + Center of the Gaussian function. + std1: float + Standard deviation along the first axis. + std2: float + Standard deviation along the second axis. + scale: float + Scaling factor. + rotation: float + Rotation angle in radians. + """ + self.center = center + self.std = np.array([std1, std2]) ** 2 # scale stds to variance + self.scale = scale + self.rotation = rotation + + self._a = np.cos(self.rotation) ** 2 / (2 * self.std[0]) + np.sin( + self.rotation + ) ** 2 / (2 * self.std[1]) + self._b = -np.sin(2 * self.rotation) / (4 * self.std[0]) + np.sin( + 2 * self.rotation + ) / (4 * self.std[1]) + self._c = np.sin(self.rotation) ** 2 / (2 * self.std[0]) + np.cos( + self.rotation + ) ** 2 / (2 * self.std[1]) + + def __call__(self, pos: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]: + """Evaluate the Gaussian function at the given positions. + + Parameters + ---------- + pos: npt.NDArray[np.float64] + Array of positions to evaluate the Gaussian function at. + + Returns + ------- + npt.NDArray[np.float64] + Array of function values at the given positions. + """ + exponent = self._a * (pos[:, 0] - self.center[0]) ** 2 + exponent += ( + 2 * self._b * (pos[:, 0] - self.center[0]) * (pos[:, 1] - self.center[1]) + ) + exponent += self._c * (pos[:, 1] - self.center[1]) ** 2 + return self.scale * np.exp(-exponent) diff --git a/molpipeline/explainability/visualization/heatmaps.py b/molpipeline/explainability/visualization/heatmaps.py new file mode 100644 index 00000000..4fdae123 --- /dev/null +++ b/molpipeline/explainability/visualization/heatmaps.py @@ -0,0 +1,276 @@ +"""Module for generating heatmaps from 2D-grids. + +Much of the visualization code in this file originates from projects of Christian W. Feldmann: + https://github.com/c-feldmann/rdkit_heatmaps + https://github.com/c-feldmann/compchemkit +""" + +import abc +from typing import Callable, Sequence + +import numpy as np +import numpy.typing as npt +from matplotlib import colors +from rdkit.Chem import Draw +from rdkit.Geometry.rdGeometry import Point2D + + +class Grid2D(abc.ABC): + """Metaclass for discrete 2-dimensional grids. + + This class holds a matrix of values accessed by index, where each cell is associated with a specific location. + """ + + def __init__( + self, + x_lim: Sequence[float], + y_lim: Sequence[float], + x_res: int, + y_res: int, + ) -> None: + """Initialize the Grid2D with limits and resolution of the axes. + + Parameters + ---------- + x_lim: Sequence[float] + Extend of the grid along the x-axis (xmin, xmax). + y_lim: Sequence[float] + Extend of the grid along the y-axis (ymin, ymax). + x_res: int + Resolution (number of cells) along x-axis. + y_res: int + Resolution (number of cells) along y-axis. + """ + if len(x_lim) != 2: + raise ValueError("x_lim must be of length 2.") + if len(y_lim) != 2: + raise ValueError("y_lim must be of length 2.") + + self.x_lim = x_lim + self.y_lim = y_lim + self.x_res = x_res + self.y_res = y_res + self.values = np.zeros((self.x_res, self.y_res)) + + @property + def dx(self) -> float: + """Length of cell in x-direction.""" + return (max(self.x_lim) - min(self.x_lim)) / self.x_res + + @property + def dy(self) -> float: + """Length of cell in y-direction.""" + return (max(self.y_lim) - min(self.y_lim)) / self.y_res + + def grid_field_center(self, x_idx: int, y_idx: int) -> tuple[float, float]: + """Center of cell specified by index along x and y. + + Parameters + ---------- + x_idx: int + cell-index along x-axis. + y_idx: int + cell-index along y-axis. + + Returns + ------- + tuple[float, float] + Coordinates of center of cell. + """ + x_coord = min(self.x_lim) + self.dx * (x_idx + 0.5) + y_coord = min(self.y_lim) + self.dy * (y_idx + 0.5) + return x_coord, y_coord + + def grid_field_lim( + self, x_idx: int, y_idx: int + ) -> tuple[tuple[float, float], tuple[float, float]]: + """Get x and y coordinates for the upper left and lower right position of specified pixel. + + Parameters + ---------- + x_idx: int + cell-index along x-axis. + y_idx: int + cell-index along y-axis. + + Returns + ------- + tuple[tuple[float, float], tuple[float, float]] + Coordinates of upper left and lower right corner of cell. + """ + upper_left = ( + min(self.x_lim) + self.dx * x_idx, + min(self.y_lim) + self.dy * y_idx, + ) + lower_right = ( + min(self.x_lim) + self.dx * (x_idx + 1), + min(self.y_lim) + self.dy * (y_idx + 1), + ) + return upper_left, lower_right + + +class ColorGrid(Grid2D): + """Stores rgba-values of cells.""" + + def __init__( + self, + x_lim: Sequence[float], + y_lim: Sequence[float], + x_res: int, + y_res: int, + ): + """Initialize the ColorGrid with limits and resolution of the axes. + + Parameters + ---------- + x_lim: Sequence[float] + Extend of the grid along the x-axis (xmin, xmax). + y_lim: Sequence[float] + Extend of the grid along the y-axis (ymin, ymax). + x_res: int + Resolution (number of cells) along x-axis. + y_res: int + Resolution (number of cells) along y-axis. + """ + super().__init__(x_lim, y_lim, x_res, y_res) + self.color_grid = np.ones((self.x_res, self.y_res, 4)) + + +class ValueGrid(Grid2D): + """Calculate and store values of cells. + + Evaluates all added functions for the position of each cell and calculates the value of each cell as sum of these + functions. + """ + + def __init__( + self, + x_lim: Sequence[float], + y_lim: Sequence[float], + x_res: int, + y_res: int, + ): + """Initialize the ValueGrid with limits and resolution of the axes. + + Parameters + ---------- + x_lim: Sequence[float] + Extend of the grid along the x-axis (xmin, xmax). + y_lim: Sequence[float] + Extend of the grid along the y-axis (ymin, ymax). + x_res: int + Resolution (number of cells) along x-axis. + y_res: int + Resolution (number of cells) along y-axis. + """ + super().__init__(x_lim, y_lim, x_res, y_res) + self.function_list: list[ + Callable[[npt.NDArray[np.float64]], npt.NDArray[np.float64]] + ] = [] + self.values = np.zeros((self.x_res, self.y_res)) + + def add_function( + self, function: Callable[[npt.NDArray[np.float64]], npt.NDArray[np.float64]] + ) -> None: + """Add a function to the grid which is evaluated for each cell, when `self.evaluate` is called. + + Parameters + ---------- + function: Callable[[npt.NDArray[np.float64]], npt.NDArray[np.float64]] + Function to be evaluated for each cell. The function should take an array of positions and return an array + of values, e.g. a Gaussian function. + """ + self.function_list.append(function) + + def evaluate(self) -> None: + """Evaluate each function for each cell. Values of cells are calculated as the sum of all function-values. + + The results are saved to `self.values`. + """ + self.values = np.zeros((self.x_res, self.y_res)) + x_y0_list = np.array( + [self.grid_field_center(x, 0)[0] for x in range(self.x_res)] + ) + x0_y_list = np.array( + [self.grid_field_center(0, y)[1] for y in range(self.y_res)] + ) + xv, yv = np.meshgrid(x_y0_list, x0_y_list) + xv = xv.ravel() + yv = yv.ravel() + coordinate_pairs = np.vstack([xv, yv]).T + for f in self.function_list: + values = f(coordinate_pairs) + values = values.reshape(self.y_res, self.x_res).T + if values.shape != self.values.shape: + raise AssertionError( + f"Function does not return correct shape. Shape was {(values.shape, self.values.shape)}" + ) + self.values += values + + def map2color( + self, + c_map: colors.Colormap, + normalizer: colors.Normalize, + ) -> ColorGrid: + """Generate a ColorGrid from `self.values` according to given colormap. + + Parameters + ---------- + c_map: colors.Colormap + Colormap to be used for mapping values to colors. + normalizer: colors.Normalize + Normalizer to be used for mapping values to colors. + + Returns + ------- + ColorGrid + ColorGrid with colors corresponding to ValueGrid. + """ + color_grid = ColorGrid(self.x_lim, self.y_lim, self.x_res, self.y_res) + norm = normalizer(self.values) + color_grid.color_grid = np.array(c_map(norm)) + return color_grid + + +def get_color_normalizer_from_data( + values: npt.NDArray[np.float64], +) -> colors.Normalize: + """Create a color normalizer based on the data distribution of 'values'. + + Parameters + ---------- + values: npt.NDArray[np.float64] + Data to derive limits of normalizer. The maximum absolute value of + values` is used as limit. + + Returns + ------- + colors.Normalize + Normalizer for colors. + """ + abs_max = np.max(np.abs(values)) + normalizer = colors.Normalize(vmin=-abs_max, vmax=abs_max) + return normalizer + + +def color_canvas(canvas: Draw.MolDraw2D, color_grid: ColorGrid) -> None: + """Draw a ColorGrid object to a RDKit Draw.MolDraw2D canvas. + + Each pixel is drawn as rectangle, so if you use Draw.MolDrawSVG brace yourself and your RAM! + + Parameters + ---------- + canvas: Draw.MolDraw2D + RDKit Draw.MolDraw2D canvas. + color_grid: ColorGrid + ColorGrid object to be drawn on the canvas. + """ + # draw only grid points whose color is not white. + # we check for the exact values of white (1,1,1). np.isclose returns almost the same pixels but is slightly slower. + mask = np.where(~np.all(color_grid.color_grid[:, :, :3] == [1, 1, 1], axis=2)) + + for x, y in zip(*mask): + upper_left, lower_right = color_grid.grid_field_lim(x, y) + upper_left, lower_right = Point2D(*upper_left), Point2D(*lower_right) + canvas.SetColour(tuple(color_grid.color_grid[x, y])) + canvas.DrawRect(upper_left, lower_right) diff --git a/molpipeline/explainability/visualization/utils.py b/molpipeline/explainability/visualization/utils.py new file mode 100644 index 00000000..b2f1a72d --- /dev/null +++ b/molpipeline/explainability/visualization/utils.py @@ -0,0 +1,173 @@ +"""Utility functions for visualization of molecules and their explanations.""" + +import io +from typing import Sequence + +import numpy as np +import numpy.typing as npt +from matplotlib import pyplot as plt +from matplotlib.colors import Colormap, ListedColormap +from matplotlib.pyplot import get_cmap +from PIL import Image +from rdkit import Chem + +# red green blue alpha tuple +RGBAtuple = tuple[float, float, float, float] + + +def get_mol_lims(mol: Chem.Mol) -> tuple[tuple[float, float], tuple[float, float]]: + """Return the extent of the molecule. + + x- and y-coordinates of all atoms in the molecule are accessed, returning min- and max-values for both axes. + + Parameters + ---------- + mol: Chem.Mol + RDKit Molecule object of which the limits are determined. + + Returns + ------- + tuple[tuple[float, float], tuple[float, float]] + Limits of the molecule. + """ + coords_list = [] + conf = mol.GetConformer(0) + for i, _ in enumerate(mol.GetAtoms()): + pos = conf.GetAtomPosition(i) + coords_list.append((pos.x, pos.y)) + coords: npt.NDArray[np.float64] = np.array(coords_list) + min_p = np.min(coords, axis=0) + max_p = np.max(coords, axis=0) + x_lim = min_p[0], max_p[0] + y_lim = min_p[1], max_p[1] + return x_lim, y_lim + + +def pad( + lim: Sequence[float] | npt.NDArray[np.float64], ratio: float +) -> tuple[float, float]: + """Take a 2-dimensional vector and adds len(vector) * ratio / 2 to each side and returns obtained vector. + + Parameters + ---------- + lim: Sequence[float] | npt.NDArray[np.float64] + Limits which are extended. + ratio: float + factor by which the limits are extended. + + Returns + ------- + List[float, float] + Extended limits + """ + diff = max(lim) - min(lim) + diff *= ratio / 2 + return lim[0] - diff, lim[1] + diff + + +def get_color_map_from_input( + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None +) -> Colormap: + """Get a colormap from a user defined color scheme. + + Parameters + ---------- + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None + The color scheme. + + Returns + ------- + Colormap + The colormap. + """ + # read user definer color scheme as ColorMap + if color is None: + coolwarm = ( + (0.017, 0.50, 0.850, 0.5), + (1.0, 1.0, 1.0, 0.5), + (1.0, 0.25, 0.0, 0.5), + ) + coolwarm = (coolwarm[2], coolwarm[1], coolwarm[0]) + color = coolwarm + if isinstance(color, Colormap): + color_map = color + elif isinstance(color, tuple): + color_map = color_tuple_to_colormap(color) # type: ignore + elif isinstance(color, str): + color_map = get_cmap(color) + else: + raise ValueError("Color must be a tuple, string or ColorMap.") + return color_map + + +def color_tuple_to_colormap( + color_tuple: tuple[RGBAtuple, RGBAtuple, RGBAtuple] +) -> Colormap: + """Convert a color tuple to a colormap. + + Parameters + ---------- + color_tuple: tuple[RGBAtuple, RGBAtuple, RGBAtuple] + The color tuple. + + Returns + ------- + Colormap + The colormap (a matplotlib data structure). + """ + if len(color_tuple) != 3: + raise ValueError("Color tuple must have 3 elements") + + # Definition of color + col1, col2, col3 = map(np.array, color_tuple) + + # Creating linear gradient for color mixing + linspace = np.linspace(0, 1, int(128)) + linspace4d = np.vstack([linspace] * 4).T + + # interpolating values for 0 to 0.5 by mixing purple and white + zero_to_half = linspace4d * col2 + (1 - linspace4d) * col3 + # interpolating values for 0.5 to 1 by mixing white and yellow + half_to_one = col1 * linspace4d + col2 * (1 - linspace4d) + + # Creating new colormap from + color_map = ListedColormap(np.vstack([zero_to_half, half_to_one])) + return color_map + + +def to_png(data: bytes) -> Image.Image: + """Show a PNG image from a byte stream. + + Parameters + ---------- + data: bytes + The image data. + + Returns + ------- + Image + The image. + """ + bio = io.BytesIO(data) + img = Image.open(bio) + return img + + +def plt_to_pil(figure: plt.Figure) -> Image.Image: + """Convert a matplotlib figure to a PIL image. + + Parameters + ---------- + figure: plt.Figure + The figure. + + Returns + ------- + Image + The image. + """ + bio = io.BytesIO() + figure.savefig(bio, format="png") + bio.seek(0) + img = Image.open(bio) + return img diff --git a/molpipeline/explainability/visualization/visualization.py b/molpipeline/explainability/visualization/visualization.py new file mode 100644 index 00000000..7a87ed76 --- /dev/null +++ b/molpipeline/explainability/visualization/visualization.py @@ -0,0 +1,494 @@ +"""Visualization functions for the explainability module. + +Much of the visualization code in this file originates from projects of Christian W. Feldmann: + https://github.com/c-feldmann/rdkit_heatmaps + https://github.com/c-feldmann/compchemkit +""" + +from __future__ import annotations + +from typing import Sequence + +import numpy as np +import numpy.typing as npt +from matplotlib import colors +from matplotlib import pyplot as plt +from matplotlib.colors import Colormap +from PIL import Image +from rdkit import Chem +from rdkit.Chem import Draw +from rdkit.Chem.Draw import rdMolDraw2D + +from molpipeline.abstract_pipeline_elements.core import RDKitMol +from molpipeline.explainability.explanation import SHAPFeatureAndAtomExplanation +from molpipeline.explainability.visualization.gauss import GaussFunctor2D +from molpipeline.explainability.visualization.heatmaps import ( + ValueGrid, + color_canvas, + get_color_normalizer_from_data, +) +from molpipeline.explainability.visualization.utils import ( + RGBAtuple, + get_color_map_from_input, + get_mol_lims, + pad, + plt_to_pil, + to_png, +) + + +def _make_grid_from_mol( + mol: Chem.Mol, + grid_resolution: Sequence[int], + padding: Sequence[float], +) -> ValueGrid: + """Create a grid for the molecule. + + Parameters + ---------- + mol: Chem.Mol + RDKit molecule object. + grid_resolution: Sequence[int] + Resolution of the grid. + padding: Sequence[float] + Padding of the grid. + + Returns + ------- + ValueGrid + ValueGrid object. + """ + xl: list[float] + yl: list[float] + xl, yl = [list(lim) for lim in get_mol_lims(mol)] # Limit of molecule + + # Extent of the canvas is approximated by size of molecule scaled by ratio of canvas height and width. + # Would be nice if this was directly accessible... + mol_height = yl[1] - yl[0] + mol_width = xl[1] - xl[0] + + height_to_width_ratio_mol = mol_height / (1e-16 + mol_width) + # the grids height / weight is the canvas height / width + height_to_width_ratio_canvas = grid_resolution[1] / grid_resolution[0] + + if height_to_width_ratio_mol < height_to_width_ratio_canvas: + mol_height_new = height_to_width_ratio_canvas * mol_width + yl[0] -= (mol_height_new - mol_height) / 2 + yl[1] += (mol_height_new - mol_height) / 2 + else: + mol_width_new = grid_resolution[0] / grid_resolution[1] * mol_height + xl[0] -= (mol_width_new - mol_width) / 2 + xl[1] += (mol_width_new - mol_width) / 2 + + xl = list(pad(xl, padding[0])) # Increasing size of x-axis + yl = list(pad(yl, padding[1])) # Increasing size of y-axis + v_map = ValueGrid(xl, yl, grid_resolution[0], grid_resolution[1]) + return v_map + + +def _add_gaussians_for_atoms( + mol: Chem.Mol, + conf: Chem.Conformer, + v_map: ValueGrid, + atom_weights: npt.NDArray[np.float64], + atom_width: float, +) -> ValueGrid: + """Add Gauss-functions centered at atoms to the grid. + + Parameters + ---------- + mol: Chem.Mol + RDKit molecule object. + conf: Chem.Conformer + Conformation of the molecule. + v_map: ValueGrid + ValueGrid object to which the functions are added. + atom_weights: npt.NDArray[np.float64] + Array of weights for atoms. + atom_width: float + Width of the displayed atom weights. + + Returns + ------- + ValueGrid + ValueGrid object with added functions. + """ + for i in range(mol.GetNumAtoms()): + if atom_weights[i] == 0: + continue + pos = conf.GetAtomPosition(i) + coords = np.array([pos.x, pos.y]) + func = GaussFunctor2D( + center=coords, + std1=atom_width, + std2=atom_width, + scale=atom_weights[i], + rotation=0, + ) + v_map.add_function(func) + return v_map + + +# pylint: disable=too-many-locals +def _add_gaussians_for_bonds( + mol: Chem.Mol, + conf: Chem.Conformer, + v_map: ValueGrid, + bond_weights: npt.NDArray[np.float64], + bond_width: float, + bond_length: float, +) -> ValueGrid: + """Add Gauss-functions centered at bonds to the grid. + + Parameters + ---------- + mol: Chem.Mol + RDKit molecule object. + conf: Chem.Conformer + Conformation of the molecule. + v_map: ValueGrid + ValueGrid object to which the functions are added. + bond_weights: npt.NDArray[np.float64] + Array of weights for bonds. + bond_width: float + Width of the displayed bond weights (perpendicular to bond-axis). + bond_length: float + Length of the displayed bond weights (along the bond-axis). + + Returns + ------- + ValueGrid + ValueGrid object with added functions. + """ + # Adding Gauss-functions centered at bonds (position between the two bonded-atoms) + for i, b in enumerate(mol.GetBonds()): + if bond_weights[i] == 0: + continue + a1 = b.GetBeginAtom().GetIdx() + a1_pos = conf.GetAtomPosition(a1) + a1_coords = np.array([a1_pos.x, a1_pos.y]) + + a2 = b.GetEndAtom().GetIdx() + a2_pos = conf.GetAtomPosition(a2) + a2_coords = np.array([a2_pos.x, a2_pos.y]) + + diff = a2_coords - a1_coords + angle = np.arctan2(diff[0], diff[1]) + + bond_center = (a1_coords + a2_coords) / 2 + + func = GaussFunctor2D( + center=bond_center, + std1=bond_width, + std2=bond_length, + scale=bond_weights[i], + rotation=angle, + ) + v_map.add_function(func) + return v_map + + +def make_sum_of_gaussians_grid( + mol: Chem.Mol, + grid_resolution: Sequence[int], + padding: Sequence[float], + atom_weights: Sequence[float] | npt.NDArray[np.float64] | None = None, + bond_weights: Sequence[float] | npt.NDArray[np.float64] | None = None, + atom_width: float = 0.3, + bond_width: float = 0.25, + bond_length: float = 0.5, +) -> rdMolDraw2D: + """Map weights of atoms and bonds to the drawing of a RDKit molecular depiction. + + For each atom and bond of depicted molecule a Gauss-function, centered at the respective object, is created and + scaled by the corresponding weight. Gauss-functions of atoms are circular, while Gauss-functions of bonds can be + distorted along the bond axis. The value of each pixel is determined as the sum of all function-values at the pixel + position. Subsequently, the values are mapped to a color and drawn onto the canvas. + + Inspired from https://github.com/c-feldmann/rdkit_heatmaps/blob/master/rdkit_heatmaps/molmapping.py + + Parameters + ---------- + mol: Chem.Mol + RDKit molecule object which is displayed. + grid_resolution: Sequence[int] + Number of pixels of x- and y-axis. + padding: Sequence[float] + Increase of heatmap size, relative to size of molecule. + atom_weights: Sequence[float] | npt.NDArray[np.float64] | None + Array of weights for atoms. + bond_weights: Sequence[float] | npt.NDArray[np.float64] | None + Array of weights for bonds. + atom_width: float + Value for the width of displayed atom weights. + bond_width: float + Value for the width of displayed bond weights (perpendicular to bond-axis). + bond_length: float + Value for the length of displayed bond weights (along the bond-axis). + + Returns + ------- + rdMolDraw2D.MolDraw2D + Drawing of molecule and corresponding heatmap. + """ + # assign default values and convert to numpy array + if atom_weights is None: + atom_weights = np.zeros(mol.GetNumAtoms()) + elif not isinstance(atom_weights, np.ndarray): + atom_weights = np.array(atom_weights) + + if bond_weights is None: + bond_weights = np.zeros(len(mol.GetBonds())) + elif not isinstance(bond_weights, np.ndarray): + bond_weights = np.array(bond_weights) + + # validate input + if not len(atom_weights) == mol.GetNumAtoms(): + raise ValueError("len(atom_weights) is not equal to number of atoms in mol") + + if not len(bond_weights) == len(mol.GetBonds()): + raise ValueError("len(bond_weights) is not equal to number of bonds in mol") + + # extract the 2D conformation of the molecule to be drawn + conf = mol.GetConformer(0) + + # setup grid and add functions for atoms and bonds + value_grid = _make_grid_from_mol(mol, grid_resolution, padding) + value_grid = _add_gaussians_for_atoms( + mol, conf, value_grid, atom_weights, atom_width + ) + value_grid = _add_gaussians_for_bonds( + mol, conf, value_grid, bond_weights, bond_width, bond_length + ) + + # evaluate all functions at pixel positions to obtain pixel values + value_grid.evaluate() + + return value_grid + + +def _structure_heatmap( + mol: RDKitMol, + atom_weights: npt.NDArray[np.float64], + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None = None, + width: int = 600, + height: int = 600, + color_limits: tuple[float, float] | None = None, +) -> tuple[Draw.MolDraw2D, ValueGrid, ValueGrid, colors.Normalize, Colormap]: + """Create a heatmap of the molecular structure, highlighting atoms with weighted Gaussian's. + + Parameters + ---------- + mol: RDKitMol + The molecule. + atom_weights: npt.NDArray[np.float64] + The atom weights. + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None + The color map. + width: int + The width of the image in number of pixels. + height: int + The height of the image in number of pixels. + color_limits: tuple[float, float] | None + The color limits. + + Returns + ------- + Draw.MolDraw2D, ValueGrid, ColorGrid, colors.Normalize, Colormap + The configured drawer, the value grid, the color grid, the normalizer, and the + color map. + """ + drawer = Draw.MolDraw2DCairo(width, height) + # Coloring atoms of element 0 to 100 black + drawer.drawOptions().updateAtomPalette({i: (0, 0, 0, 1) for i in range(100)}) + draw_opt = drawer.drawOptions() + draw_opt.padding = 0.2 + + color_map = get_color_map_from_input(color) + + # create the sums of gaussians value grid + mol_copy = Chem.Mol(mol) + mol_copy = Draw.PrepareMolForDrawing(mol_copy) + value_grid = make_sum_of_gaussians_grid( + mol_copy, + atom_weights=atom_weights, + bond_weights=None, + atom_width=0.5, # 0.4 + bond_width=0.25, + bond_length=0.5, + grid_resolution=[drawer.Width(), drawer.Height()], + padding=[draw_opt.padding * 2, draw_opt.padding * 2], + ) + + # create color-grid from the value grid. + if color_limits is None: + normalizer = get_color_normalizer_from_data(value_grid.values) + else: + normalizer = colors.Normalize(vmin=color_limits[0], vmax=color_limits[1]) + color_grid = value_grid.map2color(color_map, normalizer=normalizer) + + # draw the molecule and erase it to initialize the grid + drawer.DrawMolecule(mol) + drawer.ClearDrawing() + # add the Colormap to the canvas + color_canvas(drawer, color_grid) + # add the molecule to the canvas + drawer.DrawMolecule(mol) + + drawer.FinishDrawing() + return drawer, value_grid, color_grid, normalizer, color_map + + +def structure_heatmap( + mol: RDKitMol, + atom_weights: npt.NDArray[np.float64], + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None = None, + width: int = 600, + height: int = 600, + color_limits: tuple[float, float] | None = None, +) -> Image.Image: + """Create a Gaussian plot on the molecular structure, highlight atoms with weighted Gaussians. + + Parameters + ---------- + mol: RDKitMol + The molecule. + atom_weights: npt.NDArray[np.float64] + The atom weights. + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None + The color map. + width: int + The width of the image in number of pixels. + height: int + The height of the image in number of pixels. + color_limits: tuple[float, float] | None + The color limits. + + Returns + ------- + Image + The image as PNG. + """ + drawer, *_ = _structure_heatmap( + mol, atom_weights, color, width, height, color_limits + ) + figure_bytes = drawer.GetDrawingText() + image = to_png(figure_bytes) + return image + + +def structure_heatmap_shap( # pylint: disable=too-many-branches + explanation: SHAPFeatureAndAtomExplanation, + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None = None, + width: int = 600, + height: int = 600, + color_limits: tuple[float, float] | None = None, +) -> Image.Image: + """Create a heatmap of the molecular structure and display SHAP prediction composition. + + Parameters + ---------- + explanation: SHAPExplanation + The SHAP explanation. + color: str | Colormap | tuple[RGBAtuple, RGBAtuple, RGBAtuple] | None + The color map. + width: int + The width of the image in number of pixels. + height: int + The height of the image in number of pixels. + color_limits: tuple[float, float] | None + The color limits. + + Returns + ------- + Image + The image as PNG. + """ + if explanation.feature_weights is None: + raise ValueError("Explanation does not contain feature weights.") + if explanation.feature_vector is None: + raise ValueError("Explanation does not contain feature_vector.") + if explanation.expected_value is None: + raise ValueError("Explanation does not contain expected value.") + if explanation.prediction is None: + raise ValueError("Explanation does not contain prediction.") + if explanation.molecule is None: + raise ValueError("Explanation does not contain molecule.") + if explanation.atom_weights is None: + raise ValueError("Explanation does not contain atom weights.") + + if explanation.feature_vector.max() > 1 or explanation.feature_vector.min() < 0: + raise ValueError( + "Feature vector must be binary. Alternatively, use the structure_heatmap function instead." + ) + + if explanation.prediction.ndim > 2: + raise ValueError( + "Unsupported shape for prediction. Maximum 2 dimension is supported." + ) + + if explanation.feature_weights.ndim == 1: + feature_weights = explanation.feature_weights + elif explanation.feature_weights.ndim == 2: + feature_weights = explanation.feature_weights[:, 1] + else: + raise ValueError("Unsupported shape for feature weights.") + + # determine present/absent features using the binary feature vector + present_shap = feature_weights * explanation.feature_vector + absent_shap = feature_weights * (1 - explanation.feature_vector) + sum_present_shap = sum(present_shap) + sum_absent_shap = sum(absent_shap) + + with plt.ioff(): + + drawer, _, _, normalizer, color_map = _structure_heatmap( + explanation.molecule, + explanation.atom_weights, + color=color, + width=width, + height=height, + color_limits=color_limits, + ) + figure_bytes = drawer.GetDrawingText() + image_heatmap = to_png(figure_bytes) + image_array = np.array(image_heatmap) + + fig, ax = plt.subplots(figsize=(8, 8)) + + im = ax.imshow( + image_array, + cmap=color_map, + norm=normalizer, + ) + # remove ticks + ax.set_xticks([]) + ax.set_yticks([]) + # remove border + for spine in ax.spines.values(): + spine.set_visible(False) + + fig.colorbar(im, ax=ax, orientation="vertical", fraction=0.015, pad=0.0) + + # note: the prediction/expected value of the last array element is used + text = ( + f"$Prediction = {explanation.prediction[-1]:.2f}$ =" + "\n" + "\n" + f" $expected \ value={explanation.expected_value[-1]:.2f}$ + " # noqa: W605 # pylint: disable=W1401 + f"$features_{{present}}= {sum_present_shap:.2f}$ + " + f"$features_{{absent}}={sum_absent_shap:.2f}$" + ) + fig.text(0.5, 0.18, text, ha="center") + + image = plt_to_pil(fig) + # clear the figure and memory + plt.close(fig) + + # remove dpi info because it crashes ipython's display function + if "dpi" in image.info: + del image.info["dpi"] + # keep RDKit's image info + image.info.update(image_heatmap.info) + + return image diff --git a/molpipeline/utils/subpipeline.py b/molpipeline/utils/subpipeline.py index a55aa1c4..a507fc74 100644 --- a/molpipeline/utils/subpipeline.py +++ b/molpipeline/utils/subpipeline.py @@ -385,3 +385,61 @@ def get_all_filter_reinserter_fill_values(self) -> list[Any]: ): fill_values.add(step.wrapped_estimator.fill_value) return list(fill_values) + + +def get_featurization_subpipeline( + pipeline: Pipeline, raise_not_found: bool = False +) -> Pipeline | None: + """Get the featurization subpipeline from a pipeline. + + Parameters + ---------- + pipeline : Pipeline + The pipeline to extract the featurization subpipeline from. + raise_not_found : bool + If True, raise a ValueError if the model was not found. + + Raises + ------ + ValueError + If the model was not found and raise_not_found is True. + + Returns + ------- + Pipeline | None + The extracted featurization subpipeline or None if the featurization element was not found. + """ + pipeline_extractor = SubpipelineExtractor(pipeline) + featurization_subpipeline = pipeline_extractor.get_featurization_subpipeline() + if raise_not_found and featurization_subpipeline is None: + raise ValueError("Could not determine the featurization subpipeline.") + return featurization_subpipeline + + +def get_model_from_pipeline( + pipeline: Pipeline, raise_not_found: bool = False +) -> BaseEstimator | None: + """Get the model from a pipeline. + + Parameters + ---------- + pipeline : Pipeline + The pipeline to extract the model from. + raise_not_found : bool + If True, raise a ValueError if the model was not found. + + Raises + ------ + ValueError + If the model was not found and raise_not_found is True. + + Returns + ------- + BaseEstimator | None + The extracted model or None if the model was not found. + """ + pipeline_extractor = SubpipelineExtractor(pipeline) + model = pipeline_extractor.get_model_element() + if raise_not_found and model is None: + raise ValueError("Could not determine the model to explain.") + return model diff --git a/notebooks/introduction_to_explainable_ai.ipynb b/notebooks/introduction_to_explainable_ai.ipynb new file mode 100644 index 00000000..52bc190f --- /dev/null +++ b/notebooks/introduction_to_explainable_ai.ipynb @@ -0,0 +1,1327 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "52d2059f-af91-44cb-8606-3797d89a0b76", + "metadata": {}, + "source": [ + "# Introduction to explainable AI (XAI)\n", + "\n", + "MolPipeline supports explainability methods for machine learning models, also called explainable AI (XAI). Explainability methods provide explanations for predictions, which can help to interprete why a model made a prediction. This can help, for example, users in decision making and developers to improve machine learning models. \n", + "\n", + "This notebooks shows how explanations can be easily generated with MolPipeline. We show this with XAI explanations for a simple standard Random Forest with Morgan fingerprints model. This XAI method was introduced by [Feldmann et al. 2022](https://doi.org/10.3390/biom12040557) and uses Shapley Values from [SHAP](https://github.com/shap/shap) to explain important atoms and substructures with a heatmap on the 2D depcition of the molecular structure. For the implementation see MolPipelines `explainability` module.\n", + "\n", + "In addition, we borrow a real-world drug design data set from [Harren et al. 2022](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) and illustrate how explanations generated with MolPipeline can be used in real-world scenarios. The study by Harren et al. is a comprehensive analysis of methods for interpreting structure–activity relationships (SARs) in lead optimization with XAI from Sanofi and the University Hamburg. This notebook shows that explanations with a Random Forest model with fingerprints highlight key substructures important for affinity. However, some of the explanations differ from those by Harren et al. generated with a multilayer perceptron with the same fingerprints. This shows that explanations must always be interpreted in the context of the model and data set and that for a comprehensive interpretation multiple machine learning models should be consolidated. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "24d07cc6-81e1-48d1-b30f-6a1e1f37bf4d", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "from rdkit import Chem\n", + "from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n", + "import pandas as pd\n", + "\n", + "from molpipeline import Pipeline\n", + "from molpipeline.any2mol import AutoToMol\n", + "from molpipeline.mol2any import MolToMorganFP\n", + "from molpipeline.explainability import (\n", + " SHAPTreeExplainer,\n", + " structure_heatmap_shap,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b10eefeb-f30f-4e49-a9a7-2b0af5e78199", + "metadata": {}, + "outputs": [], + "source": [ + "RANDOM_STATE = 123456" + ] + }, + { + "cell_type": "markdown", + "id": "0c89a57a-2467-4ab0-941f-1a15ce3921dd", + "metadata": {}, + "source": [ + "## Reading the protein-ligand binding data set" + ] + }, + { + "cell_type": "markdown", + "id": "a640f22c-9568-47a9-9f1d-4601015a5902", + "metadata": {}, + "source": [ + "The data set from [Harren et al.](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) contains bioactivity measurements describing the binding of small molecules (the ligands) and the protein target.\n", + "\n", + "The bioactivity is provided as pIC50 values against the aspartic protease renin for molecular series of indole-3-carboxamides and azaindoles. The structure−activity relationship (SAR) is relatively well understood for these molecules. For example, for the indole-3-carboxamides, a PDB structure of the protein-ligand complex is available [3oot](https://www.rcsb.org/structure/3OOT), illustrating the interactions of the potent ligand \"5k\" (IC50=2 nM), that can be used to evaluate XAI explanations. See the paper of [Harren et al.](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) for useful details and references." + ] + }, + { + "cell_type": "markdown", + "id": "6d726f57-40ff-44dd-a360-76953f42e0c8", + "metadata": {}, + "source": [ + "Let's read in the molecular data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c7588c6-1c9c-4831-96a8-98223ee7c75a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pubchem_cidpubchem_inchipubchem_smilesnameoriginpIC50
054753101.0InChI=1S/C26H25FN4O2/c1-17-10-11-20(27)18(2)24...CC1=C(C(=C(C=C1)F)C)OC2=C(C3=C(N2C4=CC=CC=C4)C...b2a3mBMCL2011A8.8861
152949598.0InChI=1S/C26H24FN3O3/c1-17-7-8-18(27)15-23(17)...CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C=CC...b1i5cBMCL20108.6990
244195154.0InChI=1S/C28H28FN3O2/c1-18-20(7-6-10-22(18)29)...CC1=C(C=CC=C1F)CC2=C(C3=C(N2C4=CC=CC=C4)C=CC(=...b1i5kBMCL20108.6990
344194118.0InChI=1S/C26H25FN4O2/c1-17-8-9-21(27)18(2)24(1...CC1=C(C(=C(C=C1)F)C)OC2=C(C3=C(N2C4=CC=CC=C4)C...b2a6dBMCL2011A8.6990
453346499.0InChI=1S/C32H29FN4O2/c1-22-12-13-24(33)21-28(2...CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C(=N...b2a7dBMCL2011A8.5229
.....................
13352947015.0InChI=1S/C26H25N3O2/c1-19-18-28(17-16-27-19)25...CC1CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=C...b1i3aBMCL20105.1898
13456675445.0InChI=1S/C26H25FN4O3/c1-17-8-9-18(27)16-21(17)...CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C=CC...b2a5aBMCL2011A5.1785
13552944458.0InChI=1S/C27H27N3O2/c1-27(2)19-29(18-17-28-27)...CC1(CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=...b1i3bBMCL20105.1367
13652948980.0InChI=1S/C26H22F3N3O2/c27-26(28,29)18-7-6-10-2...C1CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=C4...b1i2cBMCL20105.0458
13752944486.0InChI=1S/C26H25FN4O2/c1-17-18(5-4-7-21(17)27)1...CC1=C(C=CC=C1F)CC2=C(C3=CC=CC=C3N2C4=CNC(=O)C=...b1i4hBMCL20105.0292
\n", + "

138 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " pubchem_cid pubchem_inchi \\\n", + "0 54753101.0 InChI=1S/C26H25FN4O2/c1-17-10-11-20(27)18(2)24... \n", + "1 52949598.0 InChI=1S/C26H24FN3O3/c1-17-7-8-18(27)15-23(17)... \n", + "2 44195154.0 InChI=1S/C28H28FN3O2/c1-18-20(7-6-10-22(18)29)... \n", + "3 44194118.0 InChI=1S/C26H25FN4O2/c1-17-8-9-21(27)18(2)24(1... \n", + "4 53346499.0 InChI=1S/C32H29FN4O2/c1-22-12-13-24(33)21-28(2... \n", + ".. ... ... \n", + "133 52947015.0 InChI=1S/C26H25N3O2/c1-19-18-28(17-16-27-19)25... \n", + "134 56675445.0 InChI=1S/C26H25FN4O3/c1-17-8-9-18(27)16-21(17)... \n", + "135 52944458.0 InChI=1S/C27H27N3O2/c1-27(2)19-29(18-17-28-27)... \n", + "136 52948980.0 InChI=1S/C26H22F3N3O2/c27-26(28,29)18-7-6-10-2... \n", + "137 52944486.0 InChI=1S/C26H25FN4O2/c1-17-18(5-4-7-21(17)27)1... \n", + "\n", + " pubchem_smiles name origin \\\n", + "0 CC1=C(C(=C(C=C1)F)C)OC2=C(C3=C(N2C4=CC=CC=C4)C... b2a3m BMCL2011A \n", + "1 CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C=CC... b1i5c BMCL2010 \n", + "2 CC1=C(C=CC=C1F)CC2=C(C3=C(N2C4=CC=CC=C4)C=CC(=... b1i5k BMCL2010 \n", + "3 CC1=C(C(=C(C=C1)F)C)OC2=C(C3=C(N2C4=CC=CC=C4)C... b2a6d BMCL2011A \n", + "4 CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C(=N... b2a7d BMCL2011A \n", + ".. ... ... ... \n", + "133 CC1CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=C... b1i3a BMCL2010 \n", + "134 CC1=C(C=C(C=C1)F)OC2=C(C3=C(N2C4=CC=CC=C4)C=CC... b2a5a BMCL2011A \n", + "135 CC1(CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=... b1i3b BMCL2010 \n", + "136 C1CN(CCN1)C(=O)C2=C(N(C3=CC=CC=C32)C4=CC=CC=C4... b1i2c BMCL2010 \n", + "137 CC1=C(C=CC=C1F)CC2=C(C3=CC=CC=C3N2C4=CNC(=O)C=... b1i4h BMCL2010 \n", + "\n", + " pIC50 \n", + "0 8.8861 \n", + "1 8.6990 \n", + "2 8.6990 \n", + "3 8.6990 \n", + "4 8.5229 \n", + ".. ... \n", + "133 5.1898 \n", + "134 5.1785 \n", + "135 5.1367 \n", + "136 5.0458 \n", + "137 5.0292 \n", + "\n", + "[138 rows x 6 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_path = Path(\"example_data\") / \"renin_harren.csv\"\n", + "df = pd.read_csv(data_path)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "0f7353cb-3818-420e-bc5a-e7f43f351ab1", + "metadata": {}, + "source": [ + "A small note on the data sets: \n", + "We use a version of the Renin data set from PubChem because automatic downloading from the journal website is prevented. This version contains only 138 instead of the original 142 compounds, since the missing molecules were not available in PubChem. This difference should be negligible for the illustrative purpose of this notebook. " + ] + }, + { + "cell_type": "markdown", + "id": "7ae0441a-660c-4362-83b7-e9e88a17e72d", + "metadata": {}, + "source": [ + "We construct RDKit molecule data structures from the SMILES and add relevant infos as properties to the molecules for convenience.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1786f5a1-bec6-475a-ba1a-9f798d4b753b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + "
nameb1i5c
originBMCL2010
pIC508.699
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mols = [Chem.MolFromSmiles(smiles) for smiles in df[\"pubchem_smiles\"]]\n", + "for prop_name in [\"name\", \"origin\", \"pIC50\"]:\n", + " for mol, prop in zip(mols, df[prop_name]):\n", + " mol.SetProp(prop_name, str(prop))\n", + "mols[1]" + ] + }, + { + "cell_type": "markdown", + "id": "9470f1df-6175-4991-bb08-9c84692f3f58", + "metadata": {}, + "source": [ + "The target values are extraxted in a separate list `y`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d2c32c0a-baf5-4c71-acb7-859ab016628b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[8.8861, 8.699, 8.699]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = [float(mol.GetProp(\"pIC50\")) for mol in mols]\n", + "y[:3]" + ] + }, + { + "cell_type": "markdown", + "id": "04ddb98e-9eba-45fd-be5f-5fc96eed9d86", + "metadata": {}, + "source": [ + "## Explaining predictions with MolPipeline" + ] + }, + { + "cell_type": "markdown", + "id": "38c88eb2-2a3f-494b-8f05-2036c9f0a815", + "metadata": {}, + "source": [ + "We start by setting up and fitting a standard Random Forest model with Morgan fingerprints on the data set with a pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fe99594a-0e06-49d9-81d4-59b735a8af5e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('auto2mol', AutoToMol()), ('morgan', MolToMorganFP(radius=3)),\n",
+       "                ('rf',\n",
+       "                 RandomForestRegressor(n_estimators=500, random_state=123456))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('auto2mol', AutoToMol()), ('morgan', MolToMorganFP(radius=3)),\n", + " ('rf',\n", + " RandomForestRegressor(n_estimators=500, random_state=123456))])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipeline = Pipeline(\n", + " [\n", + " (\"auto2mol\", AutoToMol()),\n", + " (\"morgan\", MolToMorganFP(n_bits=2048, radius=3)),\n", + " (\"rf\", RandomForestRegressor(n_estimators=500, random_state=RANDOM_STATE)),\n", + " ]\n", + ")\n", + "\n", + "pipeline.fit(mols, y)" + ] + }, + { + "cell_type": "markdown", + "id": "715075c3-cff8-4870-bd9c-7fd87b7bb7c3", + "metadata": {}, + "source": [ + "After the model is trained, we can simply pass the `pipeline` into a MolPipeline explainer and call the `explain` function to generate explanations for a list of molecules. Here we use the `SHAPTreeExplainer` which is a wrapper around [SHAP's TreeExplainer](https://shap.readthedocs.io/en/latest/generated/shap.TreeExplainer.html) that handles all necessary steps to generate explanations for molecules automatically. In addition, all molecules given to `explain` will be processed by the `pipeline` meaning all transformation, standardization and error handling steps will also be applied to explaining molecules." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "18ccba9b-42d5-4078-bc2a-b433d93d79b2", + "metadata": {}, + "outputs": [], + "source": [ + "explainer = SHAPTreeExplainer(pipeline)\n", + "explanations = explainer.explain(mols)" + ] + }, + { + "cell_type": "markdown", + "id": "641c7f21-38d7-4858-ade3-f9fca6703b53", + "metadata": {}, + "source": [ + "We can check if an explanation could be computed successfully by calling the `is_valid()` function, e.g. sometimes errors can occur for unprocessable molecules. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4c8a7790-39c6-462c-afd2-22a26c78afde", + "metadata": {}, + "outputs": [], + "source": [ + "assert all(exp for exp in explanations if not exp.is_valid())" + ] + }, + { + "cell_type": "markdown", + "id": "d7f48fd5-5cf9-4d3a-870a-4bedba58ef38", + "metadata": {}, + "source": [ + "The algorithm behind MolPipeline's `SHAPTreeExplainer` uses [SHAP's TreeExplainer](https://shap.readthedocs.io/en/latest/generated/shap.TreeExplainer.html) to estimate Shapley Values. With the Shapley Values each feature is attributed an importance value for the prediction, which we term `feature_weights`. When computed on the Morgan fingerprint, these `feature_weigths` can be mapped to `atom_weights`. The weight of an atom is the sum of all feature weights of substructures intersecting the atom, normalized by the substructure size and occurrence in the molecule. See [Feldmann et al.](https://doi.org/10.3390/biom12040557) for more details and [Harren et al.](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) for some alternative approaches for calculating atom weights." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f9b515d8-b837-4277-b1cf-17ac6e890b8e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.00033001, 0.00010306, ..., 0. , 0.00025244,\n", + " 0. ])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# feature weights for the first molecule\n", + "explanations[0].feature_weights" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ae932eb9-d144-4ed3-8f98-ad20fc37dfb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.12741071, 0.13919019, 0.07593206, 0.13930674, 0.08594195,\n", + " 0.01826992, 0.07099029, 0.03481592, 0.13192108, 0.0763856 ,\n", + " 0.06904259, 0.06558726, 0.06548176, 0.0672983 , 0.0670064 ,\n", + " 0.05595265, 0.00196574, 0.00114999, 0.00072739, 0.00114999,\n", + " 0.00196574, 0.00710791, -0.00021892, 0.00095641, -0.00198274,\n", + " 0.06092596, 0.00555693, 0.00703136, 0.00723796, 0.00834429,\n", + " 0.00433498, 0.00834429, 0.00723796])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# atom weights for the first molecule\n", + "explanations[0].atom_weights" + ] + }, + { + "cell_type": "markdown", + "id": "cb21eef9-20fb-4e8d-910a-d1389f9ce09f", + "metadata": {}, + "source": [ + "## Visualizing explanations with MolPipeline\n", + "\n", + "Now that we generated explanations, let's depict one to understand how they can be used for interpreting predictions. " + ] + }, + { + "cell_type": "markdown", + "id": "971d77d5-bf8c-4c7a-985c-a27dd9f5316a", + "metadata": {}, + "source": [ + "We select a molecule from the data set:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9b91dfea-7d87-4a2c-9d5d-1d3e7810e21a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + "
nameb3a4g
originBMCL2011B
pIC507.0506
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "explanation = explanations[55]\n", + "explanation.molecule" + ] + }, + { + "cell_type": "markdown", + "id": "4284b9d9-b1cf-4328-be1d-4f7a2c5c7fb6", + "metadata": {}, + "source": [ + "We can illustrate MolPipeline's explanations with the `structure_heatmap_shap`. This function generates an image with a 2D depiction of the molecular structure and explanations. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c5545ea6-ca77-48c6-9871-f84f7fdbfe88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "structure_heatmap_shap(\n", + " explanation\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9a3baa39-95c1-4b39-a591-32ae7a145024", + "metadata": {}, + "source": [ + "The explanations are a heatmap and a decomposition of the predicted value into three contributing factors.\n", + "\n", + "**Heatmap of the molecular structure** \n", + "Substructures associated with positive contributions by the model are highlighted in red, while substructures with negative contributions would be illustrated in blue. No color indicates no contribution. Therefore, we can interprete that substructures highlighted in red are important for high activity while blue substructures are unfavorable for activity. \n", + "\n", + "**Contribution of present/absent substructure features** \n", + "In addition to the heatmap of the structure, MolPipelines also provides a breakdown of the predicted value on the bottom of the explanation image. The model predicts a pIC50 value of 6.92 for the compound. This value can be decomposed in contributions from the expected value of the model output (see [Lundberg et al.](https://doi.org/10.48550/arXiv.1705.07874) for details), the features present and features absent using the Shapley Value-based feature weights. Since we are using Morgan binary fingerprints, present features correspond to the substructures present in the molecule, that can be seen in the image. In contrast, absent features are features that are important for the prediction but are not in the depicted molecule. For example, some features/substructures in the training set can be important for the model and that they are missing in this particular molecule influences the prediction. \n", + "\n", + "Note that this decomposition is currently only provided for binary fingerprints." + ] + }, + { + "cell_type": "markdown", + "id": "eb9cfe22-bd1e-4d40-9ff5-095a8bf646dd", + "metadata": {}, + "source": [ + "## Comparison to explanations from Harren et al.\n", + "\n", + "We compare explanations [Harren et al.](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) obtained with a simple multilayer perceptron (MLP) with Morgan fingerprints using DeepSHAP to the standard Random Forest model with Morgan fingeprints using SHAP's TreeExplainer on the real-world lead optimization data set. \n", + "\n", + "In the lead optimization step in drug discovery, it is important that a machine learning model reflects the affinity trends induced by smaller structural changes. Especially, small structural changes causing large affinity changes are of interest and the interpretations obtained from an XAI method should adequately capture and visualize these trends. The goal of applying XAI in such a project is usually to identify further small structural modification to improve affinity. See [Harren et al.](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01263) for details. " + ] + }, + { + "cell_type": "markdown", + "id": "9f9a402c-e184-478a-99b5-bddf165794e3", + "metadata": {}, + "source": [ + "For convenience we store all explanations in a dict to access them by the molecules IDs or names." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f4332475-d5c1-416b-9394-f8d3d0c0b9da", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "138" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "explanations_dict = {exp.molecule.GetProp(\"name\"): exp for exp in explanations}\n", + "len(explanations_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "ef02cd6b-0c85-441f-ab57-967b550581b3", + "metadata": {}, + "source": [ + "We will compare our explanation with the explanations in Figure 6 in Harren et al. Therefore, we extract the 3 compounds of different affinities (see Harren et al.):\n", + "\n", + "| Compound name | exp. IC50 | exp. pIC50| \n", + "| --- | --- | --- |\n", + "| 5k (b1i5k) | 0.002 | 8.70|\n", + "| 2n (b1i2n) | 0.009 | 8.05|\n", + "| 5b (b1i5b) | 1.350 | 5.87|" + ] + }, + { + "cell_type": "markdown", + "id": "2cc8a0fb-b4a4-47b6-ba99-4b4cea4f14ad", + "metadata": {}, + "source": [ + "Extract the min and max atom weight values for normalizing the coloring of the series" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cf838915-2fb1-4507-9a6d-344366f88ca4", + "metadata": {}, + "outputs": [], + "source": [ + "# series_names = [\"b1i5k\", \"b1i2n\", \"b1i5b\"]\n", + "# series_dict = {k:explanations_dict[k] for k in series_names}\n", + "series_dict = explanations_dict\n", + "\n", + "weight_min = min([exp.atom_weights.min() for exp in series_dict.values()])\n", + "weight_max = max([exp.atom_weights.max() for exp in series_dict.values()])\n", + "weight_abs_max = max(abs(weight_min), abs(weight_max))\n", + "# following Harren et al., we set the maximum color intensity to 70% of the maximal numerical value\n", + "# for better visual differentiations in low value regions.\n", + "weight_abs_max = weight_abs_max * 0.70" + ] + }, + { + "cell_type": "markdown", + "id": "47e35531-1b91-4f39-a71b-357fadd105dc", + "metadata": {}, + "source": [ + "First, let's have a look at the most active compound **5k** in the series ([Scheiper et al. 2010](https://doi.org/10.1016/j.bmcl.2010.08.092))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c5aadaed-f55a-4fa8-a471-a64bf0e9e994", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + "
nameb1i5k
originBMCL2010
pIC508.699
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "explanations_dict[\"b1i5k\"].molecule" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d9048b03-6ce6-475d-b440-4f403b45cce4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "structure_heatmap_shap(explanations_dict[\"b1i5k\"], color_limits=(-weight_abs_max, weight_abs_max))" + ] + }, + { + "cell_type": "markdown", + "id": "20bc00de-d184-4cdf-be8e-2440ff183d06", + "metadata": {}, + "source": [ + "The heatmap explanation strongly highlights a positive contribution from the indole's hydroxyl group. As also described by Harren et al., this hydroxyl has a favorable hydrogen bond with His287 (see the crystal structure [3oot](https://www.rcsb.org/structure/3OOT)), one of the key interactions of this compound. There are also smaller contributions from the methyl at the indole system and the fluorine and methyl decorations on the benzyl substituent. \n", + "\n", + "Interestingly, our heatmap explanation differs from Harren et al. (see Figure 6). The coloring using DeepSHAP in Harren et al. indicates a postive contributions from larger parts of the structure, including the whole indole system. In comparison, our heatmap is much sparser. We hypothesis that this difference is due to the machine learning algorithms used. Random Forest's predictions are potentially based on a sparser set of features as the MLP's, because a highly predictive (or important) feature will correspond to only a short path in the decision tree, considering only few features. In contrast, an MLP might be considering a larger set of all fingerprint features. \n", + "\n", + "This difference in results illustrate that explanations are hard to compare because there is no real ground truth. While Harren et al. found reasonable interpretations for the larger highlighted parts in their results, we could hypothesize that the hydroxyl's hydrogen bond is the key contributer to affinity in this compound, justifying strong highlighting. Therefore, considering multiple models and approaches seems necessary to get a comprehensive interpretation. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "20bcb584-943b-4a02-8e11-6a23ead5a0b5", + "metadata": {}, + "source": [ + "Next, we look at the **2n** compound which differs structurally only in the indole decoration to **5k** but has a 4.5-fold lower binding affinity." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "00f75eca-e30c-49cf-aa9c-6011214a852d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + "
nameb1i2n
originBMCL2010
pIC508.0458
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "explanations_dict[\"b1i2n\"].molecule" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "5c8867a2-926a-4458-8194-6edce7c000d5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "structure_heatmap_shap(explanations_dict[\"b1i2n\"], color_limits=(-weight_abs_max, weight_abs_max))" + ] + }, + { + "cell_type": "markdown", + "id": "081c4cd6-34fc-44c3-a7be-218ed30fd3fc", + "metadata": {}, + "source": [ + "This heatmap shows more but less strongy pronounced contributions than for **5k**. The benzyl's flourine and methyl decorations are the strongest contributers, while now also the whole indole system is contributing. The heatmap is in relatively well agreement with Harren et al.'s results." + ] + }, + { + "cell_type": "markdown", + "id": "ced35b64-86d0-47d1-98bf-6941443e6607", + "metadata": {}, + "source": [ + "Finally, the let's look at compound **5b**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d47913e5-ead0-47d1-910f-3f83662338da", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + "
nameb1i5b
originBMCL2010
pIC505.8697
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "explanations_dict[\"b1i5b\"].molecule" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0b1e490d-2a80-4e1b-8041-d34ddabff5ed", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "structure_heatmap_shap(explanations_dict[\"b1i5b\"], color_limits=(-weight_abs_max, weight_abs_max))" + ] + }, + { + "cell_type": "markdown", + "id": "de3fdaee-d746-4783-a0e3-1d572b56f78a", + "metadata": {}, + "source": [ + "Also for this compound, the heatmap of our Random Forest model is in relative good aggreement with the MLP-based explanations in Harren et al.'s paper. Positive contributions come from the decorated benzyl but negative contributions from the indole and it's decoration. As explained by Harren et al., the methoxy on the indole is unfavorable because its too big and lacking hydrogen bond donor potential to fit into this location in the binding pocket. " + ] + }, + { + "cell_type": "markdown", + "id": "36c1a67c-2fbf-4401-a422-9d3cf366feaf", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "Explanations for individual predictions can be easily generated with MolPipeline. The heatmap explanations on the atom level can be used to highlight important parts of the compound. In addition, SHAP-based explanations can be used to decompose a prediction in contributions from freatures present and absent in the molecule.\n", + "\n", + "The comparison on the real-world drug discovery data set from Harren et al. shows that the explanations generated with MolPipeline are reasonable and correspond to important protein-ligand interactions and are mostly in good aggreement with other methods. However, the explanation generated with MolPipeline and Random Forest can differ from these generated with an MLP and DeepSHAP. Therefore, it is essential to inteprete all explanations in the context of the data set and models used. Additionally, multiple models can be tried to get a more comprehensive interpretation. " + ] + }, + { + "cell_type": "markdown", + "id": "fd5d90f9-81d1-4d4a-893e-876a28dd8410", + "metadata": {}, + "source": [ + "## Further reading\n", + "Interpreting model predicitions with XAI methods can be challenging. Harren et al. nicely describe more of these challenges in their paper. For example, for interpreting SAR results it is important to know which part of the molecules were exchanged and which were kept static during the exploration and therefore in the data set. Substituents that are the same in all molecules of the series will likely have neutral influence on the model predictions. However, exchanging them might have a large negative or positive effect on affinity, which is likely not captured by the data, the model and the explanations. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt index c6fab9f9..d53ffddc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,9 +1,11 @@ joblib >= 1.3.0 loguru +matplotlib numpy pandas rdkit >= 2023.9.1 scipy setuptools scikit-learn >= 1.4.0 +shap typing_extensions diff --git a/tests/test_explainability/__init__.py b/tests/test_explainability/__init__.py new file mode 100644 index 00000000..dad24e8b --- /dev/null +++ b/tests/test_explainability/__init__.py @@ -0,0 +1 @@ +"""Test explainability methods and utilities.""" diff --git a/tests/test_explainability/test_shap_explainers.py b/tests/test_explainability/test_shap_explainers.py new file mode 100644 index 00000000..1e7df3f6 --- /dev/null +++ b/tests/test_explainability/test_shap_explainers.py @@ -0,0 +1,410 @@ +"""Test SHAP's TreeExplainer wrapper.""" + +import unittest + +import numpy as np +import pandas as pd +from rdkit import Chem, rdBase +from sklearn.base import BaseEstimator, is_classifier, is_regressor +from sklearn.ensemble import ( + GradientBoostingClassifier, + GradientBoostingRegressor, + RandomForestClassifier, + RandomForestRegressor, +) +from sklearn.linear_model import LinearRegression, LogisticRegression +from sklearn.svm import SVC, SVR + +from molpipeline import ErrorFilter, FilterReinserter, Pipeline, PostPredictionWrapper +from molpipeline.abstract_pipeline_elements.core import RDKitMol +from molpipeline.any2mol import SmilesToMol +from molpipeline.explainability.explainer import SHAPKernelExplainer, SHAPTreeExplainer +from molpipeline.explainability.explanation import ( + AtomExplanationMixin, + SHAPFeatureAndAtomExplanation, + SHAPFeatureExplanation, +) +from molpipeline.mol2any import ( + MolToConcatenatedVector, + MolToMorganFP, + MolToRDKitPhysChem, +) +from molpipeline.mol2mol import SaltRemover +from molpipeline.utils.subpipeline import SubpipelineExtractor +from tests.test_explainability.utils import construct_kernel_shap_kwargs + +TEST_SMILES = ["CC", "CCO", "COC", "c1ccccc1(N)", "CCC(-O)O", "CCCN"] +CONTAINS_OX = [0, 1, 1, 0, 1, 0] + +TEST_SMILES_WITH_BAD_SMILES = [ + "CC", + "CCO", + "COC", + "MY_FIRST_BAD_SMILES", + "c1ccccc1(N)", + "CCC(-O)O", + "CCCN", + "BAD_SMILES_2", +] +CONTAINS_OX_BAD_SMILES = [0, 1, 1, 0, 0, 1, 0, 1] + +_RANDOM_STATE = 67056 + + +class TestSHAPExplainers(unittest.TestCase): + """Test SHAP's Explainer wrappers.""" + + def _test_valid_explanation( + self, + explanation: SHAPFeatureExplanation | SHAPFeatureAndAtomExplanation, + estimator: BaseEstimator, + molecule_reader_subpipeline: Pipeline, + nof_features: int, + test_smiles: str, + explainer: SHAPKernelExplainer | SHAPTreeExplainer, + ) -> None: + """Helper method to test if the explanation is valid and has the correct shape and content. + + Parameters + ---------- + explanation : Explanation + The explanation to be tested. + estimator : BaseEstimator + The estimator used in the pipeline. + molecule_reader_subpipeline : Pipeline + The subpipeline that extracts the molecule from the input data. + nof_features : int + The number of features in the feature vector. + test_smiles : str + The SMILES string of the molecule. + explainer : SHAPKernelExplainer | SHAPTreeExplainer + The explainer used to generate the explanation. + """ + self.assertTrue(explanation.is_valid()) + + self.assertIsInstance(explanation.feature_vector, np.ndarray) + self.assertEqual( + (nof_features,), explanation.feature_vector.shape # type: ignore[union-attr] + ) + + # feature names should be a list of not empty strings + self.assertTrue( + all( + isinstance(name, str) and len(name) > 0 + for name in explanation.feature_names # type: ignore[union-attr] + ) + ) + self.assertEqual( + len(explanation.feature_names), explanation.feature_vector.shape[0] # type: ignore + ) + + self.assertIsInstance(explanation.molecule, RDKitMol) + self.assertEqual( + Chem.MolToInchi(*molecule_reader_subpipeline.transform([test_smiles])), + Chem.MolToInchi(explanation.molecule), + ) + + self.assertIsInstance(explanation.prediction, np.ndarray) + self.assertIsInstance(explanation.feature_weights, np.ndarray) + if is_regressor(estimator): + self.assertTrue((1,), explanation.prediction.shape) # type: ignore[union-attr] + self.assertEqual( + (nof_features,), explanation.feature_weights.shape # type: ignore[union-attr] + ) + elif is_classifier(estimator): + self.assertTrue((2,), explanation.prediction.shape) # type: ignore[union-attr] + if isinstance(explainer, SHAPTreeExplainer) and isinstance( + estimator, GradientBoostingClassifier + ): + # there is currently a bug in SHAP's TreeExplainer for GradientBoostingClassifier + # https://github.com/shap/shap/issues/3177 returning only one feature weight + # which is also based on log odds. This check is a workaround until the bug is fixed. + self.assertEqual( + (nof_features,), explanation.feature_weights.shape # type: ignore[union-attr] + ) + elif isinstance(estimator, SVC): + # SVC seems to be handled differently by SHAP. It returns only a one dimensional + # feature array for binary classification. + self.assertTrue( + (1,), explanation.prediction.shape # type: ignore[union-attr] + ) + self.assertEqual( + (nof_features,), explanation.feature_weights.shape # type: ignore[union-attr] + ) + else: + # normal binary classification case + self.assertEqual( + (nof_features, 2), explanation.feature_weights.shape # type: ignore[union-attr] + ) + else: + raise ValueError("Error in unittest. Unsupported estimator.") + + if issubclass(type(explainer), AtomExplanationMixin): + self.assertIsInstance(explanation.atom_weights, np.ndarray) # type: ignore[union-attr] + self.assertEqual( + explanation.atom_weights.shape, # type: ignore[union-attr] + (explanation.molecule.GetNumAtoms(),), # type: ignore[union-attr] + ) + + def test_explanations_fingerprint_pipeline( # pylint: disable=too-many-locals + self, + ) -> None: + """Test SHAP's TreeExplainer wrapper on MolPipeline's pipelines with fingerprints.""" + + tree_estimators = [ + RandomForestClassifier(n_estimators=2, random_state=_RANDOM_STATE), + RandomForestRegressor(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingClassifier(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingRegressor(n_estimators=2, random_state=_RANDOM_STATE), + ] + other_estimators = [ + SVC(kernel="rbf", probability=False, random_state=_RANDOM_STATE), + SVR(kernel="linear"), + LogisticRegression(random_state=_RANDOM_STATE), + LinearRegression(), + ] + n_bits = 64 + + explainer_types = [ + SHAPKernelExplainer, + SHAPTreeExplainer, + ] + explainer_estimators = [tree_estimators + other_estimators, tree_estimators] + + for estimators, explainer_type in zip(explainer_estimators, explainer_types): + + # test explanations with different estimators + for estimator in estimators: + pipeline = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ("morgan", MolToMorganFP(radius=1, n_bits=n_bits)), + ("model", estimator), + ] + ) + pipeline.fit(TEST_SMILES, CONTAINS_OX) + + # some explainers require additional kwargs + explainer_kwargs = {} + if explainer_type == SHAPKernelExplainer: + explainer_kwargs = construct_kernel_shap_kwargs( + pipeline, TEST_SMILES + ) + + explainer = explainer_type(pipeline, **explainer_kwargs) + explanations = explainer.explain(TEST_SMILES) + self.assertEqual(len(explanations), len(TEST_SMILES)) + + self.assertTrue( + issubclass(explainer.return_element_type_, AtomExplanationMixin) + ) + + # get the subpipeline that extracts the molecule from the input data + mol_reader_subpipeline = SubpipelineExtractor( + pipeline + ).get_molecule_reader_subpipeline() + self.assertIsInstance(mol_reader_subpipeline, Pipeline) + + for i, explanation in enumerate(explanations): + self._test_valid_explanation( + explanation, + estimator, + mol_reader_subpipeline, # type: ignore[arg-type] + n_bits, + TEST_SMILES[i], + explainer=explainer, # type: ignore[arg-type] + ) + + # pylint: disable=too-many-locals + def test_explanations_pipeline_with_invalid_inputs(self) -> None: + """Test SHAP's TreeExplainer wrapper with invalid inputs.""" + + # estimators to test + estimators = [ + RandomForestClassifier(n_estimators=2, random_state=_RANDOM_STATE), + RandomForestRegressor(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingClassifier(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingRegressor(n_estimators=2, random_state=_RANDOM_STATE), + ] + + # fill values considered invalid predictions + invalid_fill_values = [None, np.nan, pd.NA] + # fill values considered valid predictions (although outside the valid range) + valid_fill_values = [0, 999] + # fill values to test + fill_values = invalid_fill_values + valid_fill_values + + n_bits = 64 + + for estimator in estimators: + for fill_value in fill_values: + + # pipeline with ErrorFilter + error_filter1 = ErrorFilter() + pipeline1 = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ("salt_remover", SaltRemover()), + ("error_filter", error_filter1), + ("morgan", MolToMorganFP(radius=1, n_bits=64)), + ("model", estimator), + ] + ) + + # pipeline with ErrorFilter and FilterReinserter + error_filter2 = ErrorFilter() + error_reinserter2 = PostPredictionWrapper( + FilterReinserter.from_error_filter(error_filter2, fill_value) + ) + pipeline2 = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ("salt_remover", SaltRemover()), + ("error_filter", error_filter2), + ("morgan", MolToMorganFP(radius=1, n_bits=n_bits)), + ("model", estimator), + ("error_reinserter", error_reinserter2), + ] + ) + + for pipeline in [pipeline1, pipeline2]: + + pipeline.fit(TEST_SMILES_WITH_BAD_SMILES, CONTAINS_OX_BAD_SMILES) + + explainer = SHAPTreeExplainer(pipeline) + log_block = rdBase.BlockLogs() # pylint: disable=unused-variable + explanations = explainer.explain(TEST_SMILES_WITH_BAD_SMILES) + del log_block + self.assertEqual( + len(explanations), len(TEST_SMILES_WITH_BAD_SMILES) + ) + + # get the subpipeline that extracts the molecule from the input data + mol_reader_subpipeline = SubpipelineExtractor( + pipeline + ).get_molecule_reader_subpipeline() + self.assertIsNotNone(mol_reader_subpipeline) + + for i, explanation in enumerate(explanations): + if i in [3, 7]: + self.assertFalse(explanation.is_valid()) + continue + + self._test_valid_explanation( + explanation, + estimator, + mol_reader_subpipeline, # type: ignore[arg-type] + n_bits, + TEST_SMILES_WITH_BAD_SMILES[i], + explainer=explainer, + ) + + def test_explanations_pipeline_with_physchem(self) -> None: + """Test SHAP's TreeExplainer wrapper on physchem feature vector.""" + + estimators = [ + RandomForestClassifier(n_estimators=2, random_state=_RANDOM_STATE), + RandomForestRegressor(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingClassifier(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingRegressor(n_estimators=2, random_state=_RANDOM_STATE), + ] + + # test explanations with different estimators + for estimator in estimators: + pipeline = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ("physchem", MolToRDKitPhysChem()), + ("model", estimator), + ] + ) + + pipeline.fit(TEST_SMILES, CONTAINS_OX) + + explainer = SHAPTreeExplainer(pipeline) + explanations = explainer.explain(TEST_SMILES) + self.assertEqual(len(explanations), len(TEST_SMILES)) + + # get the subpipeline that extracts the molecule from the input data + mol_reader_subpipeline = SubpipelineExtractor( + pipeline + ).get_molecule_reader_subpipeline() + self.assertIsNotNone(mol_reader_subpipeline) + + for i, explanation in enumerate(explanations): + self._test_valid_explanation( + explanation, + estimator, + mol_reader_subpipeline, # type: ignore[arg-type] + pipeline.named_steps["physchem"].n_features, + TEST_SMILES[i], + explainer=explainer, + ) + + self.assertEqual( + explanation.feature_names, + pipeline.named_steps["physchem"].feature_names, + ) + + def test_explanations_pipeline_with_concatenated_features(self) -> None: + """Test SHAP's TreeExplainer wrapper on concatenated feature vector.""" + + estimators = [ + RandomForestClassifier(n_estimators=2, random_state=_RANDOM_STATE), + RandomForestRegressor(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingClassifier(n_estimators=2, random_state=_RANDOM_STATE), + GradientBoostingRegressor(n_estimators=2, random_state=_RANDOM_STATE), + ] + + n_bits = 64 + + # test explanations with different estimators + for estimator in estimators: + pipeline = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ( + "features", + MolToConcatenatedVector( + [ + ( + "RDKitPhysChem", + MolToRDKitPhysChem(), + ), + ( + "MorganFP", + MolToMorganFP(radius=1, n_bits=n_bits), + ), + ] + ), + ), + ("model", estimator), + ] + ) + + pipeline.fit(TEST_SMILES, CONTAINS_OX) + + explainer = SHAPTreeExplainer(pipeline) + explanations = explainer.explain(TEST_SMILES) + self.assertEqual(len(explanations), len(TEST_SMILES)) + + # get the subpipeline that extracts the molecule from the input data + mol_reader_subpipeline = SubpipelineExtractor( + pipeline + ).get_molecule_reader_subpipeline() + self.assertIsNotNone(mol_reader_subpipeline) + + for i, explanation in enumerate(explanations): + self._test_valid_explanation( + explanation, + estimator, + mol_reader_subpipeline, # type: ignore[arg-type] + pipeline.named_steps["features"].n_features, + TEST_SMILES[i], + explainer=explainer, + ) + + self.assertEqual( + explanation.feature_names, + pipeline.named_steps["features"].feature_names, + ) diff --git a/tests/test_explainability/test_visualization/__init__.py b/tests/test_explainability/test_visualization/__init__.py new file mode 100644 index 00000000..5dd7b293 --- /dev/null +++ b/tests/test_explainability/test_visualization/__init__.py @@ -0,0 +1 @@ +"""Test explainability visualization.""" diff --git a/tests/test_explainability/test_visualization/test_gaussian_grid.py b/tests/test_explainability/test_visualization/test_gaussian_grid.py new file mode 100644 index 00000000..a71da924 --- /dev/null +++ b/tests/test_explainability/test_visualization/test_gaussian_grid.py @@ -0,0 +1,65 @@ +"""Test gaussian grid visualization.""" + +import unittest +from typing import ClassVar + +import numpy as np +from rdkit import Chem +from rdkit.Chem import Draw + +from molpipeline import Pipeline +from molpipeline.explainability import ( + SHAPFeatureAndAtomExplanation, + SHAPFeatureExplanation, + SHAPTreeExplainer, +) +from molpipeline.explainability.visualization.visualization import ( + make_sum_of_gaussians_grid, +) +from tests.test_explainability.test_visualization.test_visualization import ( + _get_test_morgan_rf_pipeline, +) + +TEST_SMILES = ["CC", "CCO", "COC", "c1ccccc1(N)", "CCC(-O)O", "CCCN"] +CONTAINS_OX = [0, 1, 1, 0, 1, 0] + + +class TestSumOfGaussiansGrid(unittest.TestCase): + """Test sum of gaussian grid .""" + + # pylint: disable=duplicate-code + test_pipeline: ClassVar[Pipeline] + test_explainer: ClassVar[SHAPTreeExplainer] + test_explanations: ClassVar[ + list[SHAPFeatureAndAtomExplanation | SHAPFeatureExplanation] + ] + + @classmethod + def setUpClass(cls) -> None: + """Set up the tests.""" + cls.test_pipeline = _get_test_morgan_rf_pipeline() + cls.test_pipeline.fit(TEST_SMILES, CONTAINS_OX) + cls.test_explainer = SHAPTreeExplainer(cls.test_pipeline) + cls.test_explanations = cls.test_explainer.explain(TEST_SMILES) + + def test_grid_with_shap_atom_weights(self) -> None: + """Test grid with SHAP atom weights.""" + for explanation in self.test_explanations: + self.assertTrue(explanation.is_valid()) + self.assertIsInstance(explanation.atom_weights, np.ndarray) # type: ignore[union-attr] + + mol_copy = Chem.Mol(explanation.molecule) + mol_copy = Draw.PrepareMolForDrawing(mol_copy) + value_grid = make_sum_of_gaussians_grid( + mol_copy, + atom_weights=explanation.atom_weights, # type: ignore[union-attr] + atom_width=np.inf, + grid_resolution=[8, 8], + padding=[0.4, 0.4], + ) + self.assertIsNotNone(value_grid) + self.assertEqual(value_grid.values.size, 8 * 8) + + # test that the range of summed gaussian values is as expected for SHAP + self.assertTrue(value_grid.values.min() >= -1) + self.assertTrue(value_grid.values.max() <= 1) diff --git a/tests/test_explainability/test_visualization/test_visualization.py b/tests/test_explainability/test_visualization/test_visualization.py new file mode 100644 index 00000000..4f549b3a --- /dev/null +++ b/tests/test_explainability/test_visualization/test_visualization.py @@ -0,0 +1,213 @@ +"""Test visualization methods for explanations.""" + +import unittest +from typing import ClassVar + +import numpy as np +from rdkit import Chem +from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor + +from molpipeline import Pipeline +from molpipeline.any2mol import SmilesToMol +from molpipeline.explainability import ( + SHAPFeatureAndAtomExplanation, + SHAPFeatureExplanation, + SHAPTreeExplainer, + structure_heatmap, + structure_heatmap_shap, +) +from molpipeline.explainability.explainer import SHAPKernelExplainer +from molpipeline.mol2any import MolToMorganFP +from tests.test_explainability.utils import construct_kernel_shap_kwargs + +TEST_SMILES = ["CC", "CCO", "COC", "c1ccccc1(N)", "CCC(-O)O", "CCCN"] +CONTAINS_OX = [0, 1, 1, 0, 1, 0] # classification labels +REGRESSION_LABELS = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6] # regression labels + + +_RANDOM_STATE = 67056 + + +def _get_test_morgan_rf_pipeline(task: str = "classification") -> Pipeline: + """Get a test pipeline with Morgan fingerprints and a random forest classifier. + + Parameters + ---------- + task : str, optional (default="classification") + Task of the pipeline. Either "classification" or "regression". + + Returns + ------- + Pipeline + Pipeline with Morgan fingerprints and a random forest classifier. + """ + + if task == "classification": + model = RandomForestClassifier(n_estimators=2, random_state=_RANDOM_STATE) + elif task == "regression": + model = RandomForestRegressor(n_estimators=2, random_state=_RANDOM_STATE) + else: + raise ValueError(f"Invalid task: {task}") + + pipeline = Pipeline( + [ + ("smi2mol", SmilesToMol()), + ("morgan", MolToMorganFP(radius=1, n_bits=1024)), + ( + "model", + model, + ), + ] + ) + return pipeline + + +class TestExplainabilityVisualization(unittest.TestCase): + """Test the public interface of the visualization methods for explanations.""" + + test_pipeline_clf: ClassVar[Pipeline] + test_tree_explainer_clf: ClassVar[SHAPTreeExplainer] + test_tree_explanations_clf: ClassVar[ + list[SHAPFeatureAndAtomExplanation | SHAPFeatureExplanation] + ] + test_kernel_explainer_clf: ClassVar[SHAPKernelExplainer] + test_kernel_explanations_clf: ClassVar[ + list[SHAPFeatureAndAtomExplanation | SHAPFeatureExplanation] + ] + + test_pipeline_reg: ClassVar[Pipeline] + test_tree_explainer_reg: ClassVar[SHAPTreeExplainer] + test_tree_explanations_reg: ClassVar[ + list[SHAPFeatureAndAtomExplanation | SHAPFeatureExplanation] + ] + test_kernel_explainer_reg: ClassVar[SHAPKernelExplainer] + test_kernel_explanations_reg: ClassVar[ + list[SHAPFeatureAndAtomExplanation | SHAPFeatureExplanation] + ] + + @classmethod + def setUpClass(cls) -> None: + """Set up the tests.""" + # test pipeline for classification + cls.test_pipeline_clf = _get_test_morgan_rf_pipeline(task="classification") + cls.test_pipeline_clf.fit(TEST_SMILES, CONTAINS_OX) + + # test pipeline for regression + cls.test_pipeline_reg = _get_test_morgan_rf_pipeline(task="regression") + cls.test_pipeline_reg.fit(TEST_SMILES, REGRESSION_LABELS) + + # tree explainer for classification + cls.test_tree_explainer_clf = SHAPTreeExplainer(cls.test_pipeline_clf) + cls.test_tree_explanations_clf = cls.test_tree_explainer_clf.explain( + TEST_SMILES, + ) + + # tree explainer for regression + cls.test_tree_explainer_reg = SHAPTreeExplainer(cls.test_pipeline_reg) + cls.test_tree_explanations_reg = cls.test_tree_explainer_reg.explain( + TEST_SMILES + ) + + # kernel explainer for classification + kernel_kwargs_clf = construct_kernel_shap_kwargs( + cls.test_pipeline_clf, TEST_SMILES + ) + cls.test_kernel_explainer_clf = SHAPKernelExplainer( + cls.test_pipeline_clf, **kernel_kwargs_clf + ) + cls.test_kernel_explanations_clf = cls.test_kernel_explainer_clf.explain( + TEST_SMILES + ) + + # kernel explainer for regression + kernel_kwargs_reg = construct_kernel_shap_kwargs( + cls.test_pipeline_reg, TEST_SMILES + ) + cls.test_kernel_explainer_reg = SHAPKernelExplainer( + cls.test_pipeline_reg, **kernel_kwargs_reg + ) + cls.test_kernel_explanations_reg = cls.test_kernel_explainer_reg.explain( + TEST_SMILES + ) + + def test_structure_heatmap_fingerprint_based_atom_coloring(self) -> None: + """Test structure heatmap fingerprint-based atom coloring.""" + for explanation_list in [ + self.test_tree_explanations_clf, + self.test_kernel_explanations_clf, + self.test_tree_explanations_reg, + self.test_kernel_explanations_reg, + ]: + for explanation in explanation_list: + self.assertTrue(explanation.is_valid()) + self.assertIsInstance(explanation.atom_weights, np.ndarray) # type: ignore[union-attr] + image = structure_heatmap( + explanation.molecule, + explanation.atom_weights, # type: ignore + width=8, + height=8, + ) # type: ignore[union-attr] + self.assertIsNotNone(image) + self.assertEqual(image.format, "PNG") + + def test_structure_heatmap_shap_explanation(self) -> None: + """Test structure heatmap SHAP explanation.""" + for explanation_list in [ + self.test_tree_explanations_clf, + self.test_kernel_explanations_clf, + self.test_tree_explanations_reg, + self.test_kernel_explanations_reg, + ]: + for explanation in explanation_list: + self.assertTrue(explanation.is_valid()) + self.assertIsInstance(explanation, SHAPFeatureAndAtomExplanation) + self.assertIsInstance(explanation.atom_weights, np.ndarray) # type: ignore[union-attr] + image = structure_heatmap_shap( + explanation=explanation, # type: ignore[arg-type] + width=8, + height=8, + ) # type: ignore[union-attr] + self.assertIsNotNone(image) + self.assertEqual(image.format, "PNG") + + def test_explicit_hydrogens(self) -> None: + """Test that the visualization methods work with explicit hydrogens.""" + mol_implicit_hydrogens = Chem.MolFromSmiles("C") + explanations1 = self.test_tree_explainer_clf.explain( + [Chem.MolToSmiles(mol_implicit_hydrogens)] + ) + mol_added_hydrogens = Chem.AddHs(mol_implicit_hydrogens) + explanations2 = self.test_tree_explainer_clf.explain( + [Chem.MolToSmiles(mol_added_hydrogens)] + ) + mol_explicit_hydrogens = Chem.MolFromSmiles("[H]C([H])([H])[H]") + explanations3 = self.test_tree_explainer_clf.explain( + [Chem.MolToSmiles(mol_explicit_hydrogens)] + ) + + # test explanations' atom weights + self.assertEqual(len(explanations1), 1) + self.assertEqual(len(explanations2), 1) + self.assertEqual(len(explanations3), 1) + self.assertTrue(hasattr(explanations1[0], "atom_weights")) + self.assertTrue(hasattr(explanations2[0], "atom_weights")) + self.assertTrue(hasattr(explanations3[0], "atom_weights")) + self.assertIsInstance(explanations1[0].atom_weights, np.ndarray) # type: ignore[union-attr] + self.assertIsInstance(explanations2[0].atom_weights, np.ndarray) # type: ignore[union-attr] + self.assertIsInstance(explanations3[0].atom_weights, np.ndarray) # type: ignore[union-attr] + self.assertEqual(len(explanations1[0].atom_weights), 1) # type: ignore + self.assertEqual(len(explanations2[0].atom_weights), 1) # type: ignore + self.assertEqual(len(explanations3[0].atom_weights), 1) # type: ignore + + # test visualization + all_explanations = explanations1 + explanations2 + explanations3 + for explanation in all_explanations: + self.assertTrue(explanation.is_valid()) + image = structure_heatmap( + explanation.molecule, + explanation.atom_weights, # type: ignore + width=8, + height=8, + ) # type: ignore[union-attr] + self.assertIsNotNone(image) + self.assertEqual(image.format, "PNG") diff --git a/tests/test_explainability/utils.py b/tests/test_explainability/utils.py new file mode 100644 index 00000000..4006d9b3 --- /dev/null +++ b/tests/test_explainability/utils.py @@ -0,0 +1,36 @@ +"""Utils for explainability tests.""" + +from typing import Any + +import scipy + +from molpipeline import Pipeline +from molpipeline.utils.subpipeline import get_featurization_subpipeline + + +def construct_kernel_shap_kwargs(pipeline: Pipeline, data: list[str]) -> dict[str, Any]: + """Construct the kwargs for SHAPKernelExplainer. + + Convert sparse matrix to dense array because SHAPKernelExplainer does not + support sparse matrix as `data` and then explain dense matrices. + We stick to dense matrices for simplicity. + + Parameters + ---------- + pipeline : Pipeline + The pipeline used for featurization. + data : list[str] + The input data, e.g. SMILES strings. + + Returns + ------- + dict[str, Any] + The kwargs for SHAPKernelExplainer + """ + featurization_subpipeline = get_featurization_subpipeline( + pipeline, raise_not_found=True + ) + data_transformed = featurization_subpipeline.transform(data) # type: ignore[union-attr] + if scipy.sparse.issparse(data_transformed): + data_transformed = data_transformed.toarray() + return {"data": data_transformed}