pyAgrum-nightly 2.3.0.9.dev202512061764412981__cp310-abi3-macosx_11_0_arm64.whl

pyagrum/explain/_explInformationGraph.py

@@ -0,0 +1,264 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+import pyagrum as gum
+import pyagrum.lib._colors as gumcols
+from pyagrum.lib.bn2graph import BN2dot
+
+# Matplotlib
+import matplotlib as mpl
+
+# GL
+import warnings
+
+_cdict = {
+  "red": ((0.0, 0.1, 0.3), (1.0, 0.6, 1.0)),
+  "green": ((0.0, 0.0, 0.0), (1.0, 0.6, 0.8)),
+  "blue": ((0.0, 0.0, 0.0), (1.0, 1, 0.8)),
+}
+_INFOcmap = mpl.colors.LinearSegmentedColormap("my_colormap", _cdict, 256)
+
+
+def _normalizeVals(vals, hilightExtrema=False):
+  """
+  normalisation if vals is not a proba (max>1)
+  """
+  ma = float(max(vals.values()))
+  mi = float(min(vals.values()))
+  if ma == mi:
+    return None
+
+  if not hilightExtrema:
+    vmi = 0.01
+    vma = 0.99
+  else:
+    vmi = 0
+    vma = 1
+
+  res = {name: vmi + (val - mi) * (vma - vmi) / (ma - mi) for name, val in vals.items()}
+  return res
+
+
+def getInformationGraph(bn, evs=None, size=None, cmap=_INFOcmap, withMinMax=False):
+  """
+  Create a dot representation of the information graph for this BN
+
+  Parameters
+  ----------
+  bn: gum.BayesNet
+    the BN
+  evs : Dict[str,str|int|List[float]]
+    map of evidence
+  size: str|int
+    size of the graph
+  cmap: matplotlib.colors.Colormap
+    color map
+  withMinMax: bool
+    min and max in the return values ?
+
+  Returns
+  -------
+  dot.Dot | Tuple[dot.Dot,float,float,float,float]
+    graph as a dot representation and if asked, min_information_value, max_information_value, min_mutual_information_value, max_mutual_information_value
+  """
+  if size is None:
+    size = gum.config["notebook", "default_graph_size"]
+
+  if evs is None:
+    evs = {}
+
+  ie = gum.LazyPropagation(bn)
+  ie.setEvidence(evs)
+  ie.makeInference()
+
+  idEvs = ie.hardEvidenceNodes() | ie.softEvidenceNodes()
+
+  nodevals = dict()
+  for n in bn.nodes():
+    if n not in idEvs:
+      v = ie.H(n)
+      if v != v:  # is NaN
+        warnings.warn(f"For {bn.variable(n).name()}, entropy is NaN.")
+        v = 0
+      nodevals[bn.variable(n).name()] = v
+
+  arcvals = dict()
+  for x, y in bn.arcs():
+    v = ie.jointMutualInformation({x, y})
+    if v != v:  # is NaN
+      warnings.warn(f"For {bn.variable(x).name()}->{bn.variable(y).name()}, mutual information is Nan.")
+      v = 0
+    arcvals[(x, y)] = v
+
+  gr = BN2dot(
+    bn,
+    size,
+    nodeColor=_normalizeVals(nodevals, hilightExtrema=False),
+    arcWidth=arcvals,
+    cmapNode=cmap,
+    cmapArc=cmap,
+    showMsg=nodevals,
+  )
+
+  if withMinMax:
+    mi_node = min(nodevals.values())
+    ma_node = max(nodevals.values())
+    mi_arc = min(arcvals.values())
+    ma_arc = max(arcvals.values())
+    return gr, mi_node, ma_node, mi_arc, ma_arc
+  else:
+    return gr
+
+
+def _reprInformation(bn, evs=None, size=None, cmap=_INFOcmap, asString=False):
+  """
+  repr a bn annotated with results from inference : Information and mutual information
+
+  Parameters
+  ----------
+  bn: pyagrum.BayesNet
+    the model
+  evs: Dict[str|int,str|int|List[float]]
+    the observations
+  size: int|str
+    size of the rendered graph
+  cmap: matplotlib.colours.Colormap
+    the cmap
+  asString: bool
+    returns the string or display the HTML
+
+  Returns
+  -------
+  str|None
+    return the HTML string or directly display it.
+  """
+  import IPython.display
+  import IPython.core.pylabtools
+  from base64 import encodebytes
+  from matplotlib.backends.backend_agg import FigureCanvasAgg as fc
+
+  if size is None:
+    size = gum.config["notebook", "default_graph_size"]
+
+  if evs is None:
+    evs = {}
+
+  gr, mi, ma, _, _ = getInformationGraph(bn, evs, size, cmap, withMinMax=True)
+  gumcols.prepareDot(gr, size=size)
+
+  # dynamic member makes pylink unhappy
+  # pylint: disable=no-member
+  gsvg = IPython.display.SVG(gr.create_svg(encoding="utf-8"))
+  width = (
+    int(gsvg.data.split("width=")[1].split('"')[1].split("pt")[0]) / mpl.pyplot.rcParams["figure.dpi"]
+  )  # pixel in inches
+  if width < 5:
+    width = 5
+
+  fig = mpl.figure.Figure(figsize=(width, 1))
+  fig.patch.set_alpha(0)
+  canvas = fc(fig)
+  ax1 = fig.add_axes([0.05, 0.80, 0.9, 0.15])
+  norm = mpl.colors.Normalize(vmin=mi, vmax=ma)
+  cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation="horizontal")
+  cb1.set_label("Entropy")
+  cb1.ax.text(mi, -2, f"{mi:.4f}", ha="left", va="top", color=gumcols.proba2bgcolor(0.01, cmap))
+  cb1.ax.text(ma, -2, f"{ma:.4f}", ha="right", va="top", color=gumcols.proba2bgcolor(0.99, cmap))
+  png = IPython.core.pylabtools.print_figure(canvas.figure, "png")  # from IPython.core.pylabtools
+  png_legend = f"<img style='vertical-align:middle' src='data:image/png;base64,{encodebytes(png).decode('ascii')}'>"
+
+  sss = f"<div align='center'>{gsvg.data}<br/>{png_legend}</div>"
+
+  if asString:
+    return sss
+
+  return IPython.display.display(IPython.display.HTML(sss))
+
+
+def getInformation(bn, evs=None, size=None, cmap=_INFOcmap) -> str:
+  """
+  get a HTML string for a bn annotated with results from inference : entropy and mutual information
+
+  Parameters
+  ----------
+  bn: pyagrum.BayesNet
+    the model
+  evs: Dict[str|int,str|int|List[float]]
+    the observations
+  size: int|str
+    size of the rendered graph
+  cmap: matplotlib.colours.Colormap
+    the cmap
+
+  Returns
+  -------
+  str
+    return the HTML string
+  """
+  if size is None:
+    size = gum.config["notebook", "default_graph_size"]
+
+  if evs is None:
+    evs = {}
+
+  return _reprInformation(bn, evs, size, cmap, asString=True)
+
+
+def showInformation(bn, evs=None, size=None, cmap=_INFOcmap):
+  """
+  diplay a bn annotated with results from inference : entropy and mutual information
+
+  Parameters
+  ----------
+  bn: pyagrum.BayesNet
+    the model
+  evs: Dict[str|int,str|int|List[float]]
+    the observations
+  size: int|str
+    size of the rendered graph
+  cmap: matplotlib.colours.Colormap
+    the cmap
+  """
+  if evs is None:
+    evs = {}
+
+  if size is None:
+    size = gum.config["notebook", "default_graph_size"]
+  return _reprInformation(bn, evs, size, cmap, asString=False)

pyagrum/explain/notebook/__init__.py

@@ -0,0 +1,54 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+__author__ = "Pierre-Henri Wuillemin"
+__copyright__ = "(c) 2019-2025 PARIS"
+
+from ._bar import bar
+from ._beeswarm import beeswarm
+from ._waterfall import waterfall
+from ._showShapValues import showShapValues
+
+__all__ = [
+  "bar",
+  "beeswarm",
+  "waterfall",
+  "showShapValues",
+]

pyagrum/explain/notebook/_bar.py

@@ -0,0 +1,142 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+import pyagrum as gum
+from pyagrum.explain._Explanation import Explanation
+
+import numpy as np
+
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap, to_rgb
+from matplotlib.patches import Patch
+
+
+def bar(explanation: Explanation, y: int = None, ax: plt.Axes = None, percentage: bool = False) -> plt.axis:
+  """
+  Plots a horizontal bar chart of the mean absolute SHAP/SHALL values for each feature in the explanation.
+
+  Parameters:
+  ----------
+  explanation : Explanation
+      The explanation object containing the SHAP/SHALL values.
+  y : int, optional
+      If the values type of the explanation is SHALL, then y is ignored.
+      Else it is the class for which to plot the SHAP values (default is None, which plots multi-bar for all classes).
+  ax : plt.Axes, optional
+      The matplotlib Axes object to plot on (default is None, which creates a new figure).
+  percentage: bool
+    if True, the importance plot is shown in percent.
+
+  Raises :
+  ------
+  TypeError : If `explanation` is not an Explanation object or if `y` is not an integer or None.
+  IndexError : If `y` is an integer but out of bounds for the explanation keys.
+  """
+
+  if not isinstance(explanation, Explanation):
+    raise TypeError(f"`explanation` must be an Explanation object but got {type(explanation)}")
+
+  # Determine if The explanation object is a SHALL or SHAP explanation
+  if explanation.values_type == "SHAP":
+    if not isinstance(y, int) and y is not None:
+      raise TypeError(f"`y` must be either a positive integer or None, but got {type(y)}")
+    if isinstance(y, int) and (y < min(explanation.keys()) or y > max(explanation.keys())):
+      raise IndexError(f"Target index y={y} is out of bounds; expected 0 <= y < {max(explanation.keys()) + 1}.")
+  elif explanation.values_type == "SHALL":
+    # We force y to be an integer, so we can use the same code after for both explanations
+    y = 0
+  else:
+    raise ValueError(f"Wrong values type, expected SHAP/SHALL but got {explanation.values_type}")
+
+  if ax is None:
+    _, ax = plt.subplots(figsize=(6, 4))
+
+  if y is not None:
+    importances = explanation.importances[y] if explanation.values_type == "SHAP" else explanation.importances
+    columns = [col for col in sorted(importances.keys(), key=importances.get)]
+    values = [importances[feat] for feat in columns]
+    if percentage:
+      total = sum(values)
+      values = [(v / total) * 100 for v in values]
+    ax.barh(columns, values, color=gum.config["notebook", "tensor_color_0"], height=0.5, alpha=0.8)
+  else:
+    classes = sorted(explanation.keys())
+    cmap = LinearSegmentedColormap.from_list(
+      "class_cmap", [to_rgb(gum.config["notebook", "tensor_color_0"]), to_rgb(gum.config["notebook", "tensor_color_1"])]
+    )
+    colors = [cmap(i / (len(explanation) - 1)) for i in range(len(explanation))]
+
+    n_features = len(explanation.feature_names)
+    values = np.array([[explanation.importances[z][feat] for feat in explanation.feature_names] for z in classes])
+    # Sort bars
+    indices = np.argsort(np.sum(values, axis=0))
+    values = values[:, indices]
+    features = [explanation.feature_names[i] for i in indices]
+    bottom = np.zeros(n_features)
+
+    for i, cls in enumerate(classes):
+      contribs = values[i]
+      if percentage:
+        total = sum(contribs)
+        contribs = [(v / total) * 100 for v in contribs]
+      ax.barh(
+        features, contribs, height=0.5, left=bottom, color=colors[i % len(colors)], label=f"class {cls}", alpha=0.8
+      )
+
+      bottom += contribs
+    legend_elements = [Patch(facecolor=colors[i], edgecolor="black", label=f"Class {i}") for i in range(len(colors))]
+    ax.legend(loc="lower right", handles=legend_elements, title="Classes")
+
+  ax.set_title("Feature Importance", fontsize=16)
+
+  msg = " in %" if percentage else ""
+  ax.set_xlabel(f"mean(|{explanation.values_type} value|){msg}", fontsize=12)
+  ax.set_ylabel("Features", fontsize=12)
+  ax.tick_params(axis="x", labelsize=10)
+  ax.tick_params(axis="y", labelsize=10)
+
+  # Removing spines
+  ax.grid(axis="x", linestyle=":", alpha=0.6)
+  ax.grid(axis="y", linestyle=":", alpha=0.3)
+  ax.spines["top"].set_visible(False)
+  ax.spines["bottom"].set_visible(False)
+  ax.spines["left"].set_visible(False)
+  ax.spines["right"].set_visible(False)
+  ax.figure.set_facecolor("white")

pyagrum/explain/notebook/_beeswarm.py

@@ -0,0 +1,174 @@
+############################################################################
+#   This file is part of the aGrUM/pyAgrum library.                        #
+#                                                                          #
+#   Copyright (c) 2005-2025 by                                             #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#                                                                          #
+#   The aGrUM/pyAgrum library is free software; you can redistribute it    #
+#   and/or modify it under the terms of either :                           #
+#                                                                          #
+#    - the GNU Lesser General Public License as published by               #
+#      the Free Software Foundation, either version 3 of the License,      #
+#      or (at your option) any later version,                              #
+#    - the MIT license (MIT),                                              #
+#    - or both in dual license, as here.                                   #
+#                                                                          #
+#   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    #
+#                                                                          #
+#   This aGrUM/pyAgrum library is distributed in the hope that it will be  #
+#   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          #
+#   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS #
+#   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   #
+#   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER #
+#   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        #
+#   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
+#   OTHER DEALINGS IN THE SOFTWARE.                                        #
+#                                                                          #
+#   See LICENCES for more details.                                         #
+#                                                                          #
+#   SPDX-FileCopyrightText: Copyright 2005-2025                            #
+#       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 #
+#       - Christophe GONZALES(_at_AMU)                                     #
+#   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      #
+#                                                                          #
+#   Contact  : info_at_agrum_dot_org                                       #
+#   homepage : http://agrum.gitlab.io                                      #
+#   gitlab   : https://gitlab.com/agrumery/agrum                           #
+#                                                                          #
+############################################################################
+
+import pyagrum as gum
+from pyagrum.explain._Explanation import Explanation
+
+import numpy as np
+
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+from matplotlib import colors
+
+
+def beeswarm(
+  explanation: Explanation, y: int = 1, max_display: int = 20, color_bar: bool = True, ax=None, sort: bool = True
+):
+  """
+  Plots a beeswarm plot of the Shapley values for a given target class.
+  Parameters:
+  ----------
+  explanation : Explanation
+      The explanation object containing the SHAP/SHALL values.
+  y : int
+      If the values type of the explanation is SHALL, then y is ignored.
+      Else it is the class for which to plot the SHAP values.
+  max_display : int, optional
+      The maximum number of features to display in the beeswarm plot (default is 20).
+  color_bar : bool, optional
+      If True, adds a color bar to the plot (default is True).
+  ax : plt.Axes, optional
+      The matplotlib Axes object to plot on (default is None, which creates a new figure).
+  sort : bool, optional
+      If True, sorts the features by their importance before plotting (default is True).
+
+  Raises:
+  ------
+  TypeError
+      If `explanation` is not an Explanation object, if `y` is not an integer or if the explanation is not global (i.e., does not contain lists of contributions for each feature).
+  IndexError
+      If `y` is out of bounds for the explanation keys.
+  """
+  # Check parameters
+  if not isinstance(explanation, Explanation):
+    raise TypeError("`explanation` must be an Explanation object but got {}".format(type(explanation)))
+
+  # Determine if The explanation object is a SHALL or SHAP explanation
+  if explanation.values_type == "SHAP":
+    if not isinstance(y, int):
+      raise TypeError("`y` must be an integer but got {}".format(type(y)))
+    if y < min(explanation.keys()) or y > max(explanation.keys()):
+      raise IndexError(f"Target index y={y} is out of bounds; expected 0 <= y < {max(explanation.keys()) + 1}.")
+    contributions = explanation[y]
+    importances = explanation.importances[y]
+  elif explanation.values_type == "SHALL":
+    contributions = explanation
+    importances = explanation.importances
+  else:
+    raise ValueError(f"Wrong values type, expected SHAP/SHALL but got {explanation.values_type}")
+
+  feature_names = explanation.feature_names
+  if not isinstance(list(contributions.values())[0], list):
+    raise TypeError("For beeswarm plot, explanation must be global.")
+  values = np.array([contributions[k] for k in feature_names]).T
+  features = explanation.data
+
+  # Create the figure and axis if not provided
+  if ax == None:
+    _, ax = plt.subplots()
+
+  # Prepare the y-axis positions
+  y_positions = np.arange(min(max_display, len(feature_names)), 0, -1)
+
+  # Plot the beeswarm
+  ax.plot([0, 0], [y_positions[-1] - 0.25, y_positions[0] + 0.25], linestyle="--", color="gray")
+  color1 = gum.config["notebook", "tensor_color_0"]
+  color2 = gum.config["notebook", "tensor_color_1"]
+  cmap = colors.LinearSegmentedColormap.from_list("custom_red_green", [color1, color2])
+
+  if sort:
+    indices = [feature_names.index(feat) for feat in sorted(importances, key=importances.get, reverse=True)]
+  else:
+    indices = np.arange(min(max_display, values.shape[1]))
+
+  for k, j in enumerate(indices):
+    base = y_positions[k]
+    sequence = np.arange(values.shape[0])
+    np.random.shuffle(sequence)
+
+    shapes = values[sequence, j]
+    rounded_x = np.round(shapes, 2)
+    (unique, counts) = np.unique(rounded_x, return_counts=True)
+    density_map = dict(zip(unique, counts))
+    densities = np.array([density_map[val] for val in rounded_x])
+
+    sigmas = (densities / np.max(densities)) * 0.1
+    ords = np.random.normal(loc=base, scale=sigmas)
+
+    vals = features[sequence, j]
+
+    minimum = vals.min()
+    maximum = vals.max()
+    norm = colors.Normalize(vmin=minimum, vmax=maximum)
+    sm = cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+
+    ax.scatter(
+      shapes,
+      ords,
+      c=vals,
+      cmap=cmap,
+      s=7,
+    )
+
+  ax.set_yticks(y_positions)
+  ax.set_yticklabels([feature_names[i] for i in indices])
+  if color_bar:
+    norm = colors.Normalize(vmin=0.0, vmax=1.0)
+    sm = cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+    cbar = plt.colorbar(sm, ax=ax)
+    cbar.set_label("Feature value")
+    cbar.set_ticks([0, 1])
+    cbar.set_ticklabels(["Low", "High"])
+
+  ax.set_ylim(y_positions[-1] - 0.5, y_positions[0] + 0.5)
+  ax.set_xlabel("Impact on model Output", fontsize=12)
+  ax.set_ylabel("Features", fontsize=12)
+  ax.set_title(f"{explanation.values_type} value (Impact on model Output)", fontsize=16)
+
+  # Setting the style
+  ax.grid(axis="x", linestyle=":", alpha=0.5)
+  ax.grid(axis="y", linestyle=":", alpha=0.5)
+  ax.spines["top"].set_visible(False)
+  ax.spines["bottom"].set_visible(False)
+  ax.spines["left"].set_visible(False)
+  ax.spines["right"].set_visible(False)
+  ax.figure.set_facecolor("white")