pyAgrum-nightly 2.3.1.9.dev202512261765915415__cp310-abi3-macosx_10_15_x86_64.whl

pyagrum/explain/_ShapleyValues.py

@@ -0,0 +1,298 @@
+############################################################################
+#   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                           #
+#                                                                          #
+############################################################################
+
+from pyagrum.explain._Explainer import Explainer
+from abc import abstractmethod
+from pyagrum.explain._Explanation import Explanation
+
+# Calculations
+import pandas as pd
+import numpy as np
+
+# aGrUM
+import pyagrum as gum
+
+# GL
+import warnings
+
+
+class ShapleyValues(Explainer):
+  """
+  The ShapleyValues class is an abstract base class for computing Shapley values in a Bayesian Network.
+  """
+
+  def __init__(self, bn, target, logit):
+    """
+    Parameters:
+    ------
+    bn : pyagrum.BayesNet
+        The Bayesian Network.
+    target : int | str
+        The node id (or node name) of the target.
+    logit : bool
+        If True, applies the logit transformation to the probabilities.
+
+    Raises:
+    ------
+    TypeError : If bn is not a gum.BayesNet or target is not an integer or string.
+    ValueError : If target is not a valid node id in the Bayesian Network.
+    """
+    super().__init__(bn)
+    if isinstance(target, str):
+      if target not in bn.names():
+        raise ValueError("Target node name '{}' not found in the Bayesian Network.".format(target))
+      target = bn.idFromName(target)  # Convert node name to ID.
+    elif isinstance(target, int):
+      if target not in bn.nodes():
+        raise ValueError("Target node ID {} not found in the Bayesian Network.".format(target))
+    else:
+      raise TypeError("Target must be a node ID (int) or a node name (str), but got {}".format(type(target)))
+    if not isinstance(logit, bool):
+      warnings.warn("logit should be a boolean, unexpected calculation may occur.", UserWarning)
+
+    # Class attributes.
+    self.target = target  # ID of the target node.
+    self.target_name = self.feat_names[self.target]
+    self._mb = self._markov_blanket()
+    self.ie = gum.LazyPropagation(self.bn)  # Inference engine for the Bayesian Network.
+    self.ie.addTarget(self.target)  # Setting the target for inference.
+    self.func = self._logit if logit else self._identity  # Function to apply to the probabilities.
+
+  def _markov_blanket(self):
+    # Retrieves the Markov blanket of the target node.
+    mb = gum.MarkovBlanket(self.bn, self.target).nodes()
+    mb.remove(self.target)
+    return sorted(list(mb))
+
+  def _posterior(self, evidces: dict[int, int]):
+    # Returns the posterior probability of the target given the evidence.
+    self.ie.updateEvidence(evidces)
+    return self.ie.posterior(self.target).toarray()
+
+  @abstractmethod
+  def _shap_1dim(self, x, elements):
+    # Computes the Shapley values for a single instance.
+    # This method should be implemented in subclasses.
+    raise NotImplementedError("This method should be implemented in subclasses.")
+
+  @abstractmethod
+  def _shap_ndim(self, x, elements):
+    # Computes the Shapley values for multiple instances.
+    # This method should be implemented in subclasses.
+    raise NotImplementedError("This method should be implemented in subclasses.")
+
+  def compute(self, data: tuple | None, N=100):
+    """
+    Computes the Shapley values for the target node based on the provided data.
+
+    Parameters:
+    ----------
+    data : tuple | None
+        A tuple containing a pandas DataFrame, Series or a dictionary and a boolean indicating whether data are provided with labels. If None, a random sample of size N is generated.
+    N : int
+        The number of samples to generate if data is None.
+
+    Returns:
+    -------
+    Explanation
+        An Explanation object containing the Shapley values and importances for the target node.
+
+    Raises:
+    ------
+    TypeError : If the first element of data is not a pd.DataFrame, pd.Series or dict, or if N is not an integer when data is None.
+    ValueError : If N is less than 2 when data is None.
+    """
+    if data is None:
+      if not isinstance(N, int):
+        raise TypeError("Since df is None, N must be an integer, but got {}".format(type(N)))
+      if N < 2:
+        raise ValueError("N must be greater than 1, but got {}".format(N))
+      y = gum.generateSample(self.bn, N, with_labels=False)[0].reindex(columns=self.feat_names).to_numpy()
+      elements = [i for i in range(self.M) if i != self.target]
+      # Remove duplicate rows in x and unused columns.
+      mask_cols = [i for i in range(self.M) if i not in elements]
+      _, idx = np.unique(y[:, elements], axis=0, return_index=True)
+      y = y[idx, :]
+      y[:, mask_cols] = 0
+      contributions = self._shap_ndim(y, sorted(elements))
+
+    else:
+      if not isinstance(data, tuple):
+        raise TypeError(f"`data` must be a tuple (pd.DataFrame, bool).")
+      df, with_labels = data
+      if not isinstance(with_labels, bool):
+        warnings.warn(
+          f"The second element of `data` should be a boolean, but got {type(with_labels)}. Unexpected calculations may occur."
+        )
+      dtype = "U50" if with_labels else int
+
+      if isinstance(df, pd.Series):
+        # Here we are sure that df is a single instance (a Series).
+        s = df.dropna()
+        x = np.empty(self.M, dtype=dtype)
+        elements = []
+        for feat in s.index:
+          id = self.bn.idFromName(feat)
+          x[id] = s[feat]
+          if id != self.target:
+            elements.append(id)
+        if with_labels:
+          y = self._labelToPos_row(x, elements)
+        else:
+          y = x
+        contributions = self._shap_1dim(y, sorted(elements))
+
+      elif isinstance(df, pd.DataFrame):
+        df_clean = df.dropna(axis=1)
+        if len(df_clean) == 1:
+          # Here we are sure that df is a single instance (a DataFrame with one row).
+          x = np.empty(self.M, dtype=dtype)
+          elements = []
+          for feat in df_clean.columns:
+            id = self.bn.idFromName(feat)
+            x[id] = df_clean[feat].values[0]
+            if id != self.target:
+              elements.append(id)
+          if with_labels:
+            y = self._labelToPos_row(x, elements)
+          else:
+            y = x
+          contributions = self._shap_1dim(y, sorted(elements))
+
+        else:
+          x = np.empty((len(df_clean), self.M), dtype=dtype)
+          elements = []
+          for feat in df_clean.columns:
+            id = self.bn.idFromName(feat)
+            x[:, id] = df_clean[feat].values
+            if id != self.target:
+              elements.append(id)
+          # Remove duplicate rows in x and unused columns.
+          mask_cols = [i for i in range(self.M) if i not in elements]
+          _, idx = np.unique(x[:, elements], axis=0, return_index=True)
+          x = x[idx, :]
+          x[:, mask_cols] = 0
+          if with_labels:
+            y = self._labelToPos_df(x, elements)
+          else:
+            y = x
+          contributions = self._shap_ndim(y, sorted(elements))
+
+      elif isinstance(df, dict):
+        try:
+          N = len(list(df.values())[0])
+          if not isinstance(list(df.values())[0], (list, np.ndarray)):
+            raise TypeError("Each value in the dictionary must be a list or a numpy array.")
+          elements = []
+          x = np.empty((N, self.M), dtype=dtype)
+          for feat in df.keys():
+            if all(not (x is None) and not (isinstance(x, float) and np.isnan(x)) for x in df[feat]):
+              id = self.bn.idFromName(feat)
+              x[:, id] = df[feat]
+              if id != self.target:
+                elements.append(id)
+          # Remove duplicate rows in x and unused columns.
+          mask_cols = [i for i in range(self.M) if i not in elements]
+          _, idx = np.unique(x[:, elements], axis=0, return_index=True)
+          x = x[idx, :]
+          x[:, mask_cols] = 0
+          if with_labels:
+            y = self._labelToPos_df(x, elements)
+          else:
+            y = x
+          contributions = self._shap_ndim(y, sorted(elements))
+
+        except TypeError:
+          # Here we are sure that df is a single instance (a dictionary with one row).
+          x = np.empty(self.M, dtype=dtype)
+          elements = []
+          for feat in df.keys():
+            if not (df[feat] is None):
+              id = self.bn.idFromName(feat)
+              x[id] = df[feat]
+              if id != self.target:
+                elements.append(id)
+          if with_labels:
+            y = self._labelToPos_row(x, elements)
+          else:
+            y = x
+          contributions = self._shap_1dim(y, sorted(elements))
+
+      else:
+        raise TypeError(
+          "The first element of `data` must be a pandas DataFrame, Series or a dictionary, but got {}".format(type(df))
+        )
+
+    if contributions.ndim == 2:
+      values = {
+        z: {self.feat_names[i]: float(contributions[i, z]) for i in elements} for z in range(contributions.shape[1])
+      }
+      importances = {
+        z: {self.feat_names[i]: abs(float(contributions[i, z])) for i in elements}
+        for z in range(contributions.shape[1])
+      }
+      explanation = Explanation(
+        values,
+        importances,
+        list(self.feat_names[sorted(elements)]),
+        x[sorted(elements)],
+        self.baseline,
+        self.func.__name__,
+        "SHAP",
+      )
+    else:
+      values = {
+        z: {self.feat_names[i]: [float(v) for v in contributions[i, :, z]] for i in elements}
+        for z in range(contributions.shape[2])
+      }
+      mean_abs = np.mean(np.abs(contributions), axis=1)
+      importances = {
+        z: {self.feat_names[i]: abs(float(mean_abs[i, z])) for i in elements} for z in range(contributions.shape[2])
+      }
+      explanation = Explanation(
+        values,
+        importances,
+        list(self.feat_names[sorted(elements)]),
+        y[:, sorted(elements)],
+        self.baseline,
+        self.func.__name__,
+        "SHAP",
+      )
+    return explanation

pyagrum/explain/__init__.py

@@ -0,0 +1,81 @@
+############################################################################
+#   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                           #
+#                                                                          #
+############################################################################
+
+"""
+This module provides classes for explaining predictions and other computations made by the bayesian networks.
+"""
+
+__author__ = "Pierre-Henri Wuillemin"
+__copyright__ = "(c) 2019-2025 PARIS"
+
+# Shapley Values
+from ._ShapConditionalValues import ConditionalShapValues
+from ._ShapMarginalValues import MarginalShapValues
+from ._ShapCausalValues import CausalShapValues
+from ._Explanation import Explanation
+
+# Shall Values
+from ._ShallConditionalValues import ConditionalShallValues
+from ._ShallMarginalValues import MarginalShallValues
+from ._ShallCausalValues import CausalShallValues
+
+# Independence List For Pairs
+from ._explIndependenceListForPairs import independenceListForPairs
+
+# Generalized Markov Blanket
+from ._explGeneralizedMarkovBlanket import generalizedMarkovBlanket
+
+# Entropy and Mutual Information
+from ._explInformationGraph import getInformationGraph, getInformation, showInformation
+
+__all__ = [
+  "ConditionalShapValues",
+  "MarginalShapValues",
+  "CausalShapValues",
+  "ConditionalShallValues",
+  "MarginalShallValues",
+  "CausalShallValues",
+  "Explanation",
+  "independenceListForPairs",
+  "generalizedMarkovBlanket",
+  "getInformationGraph",
+  "getInformation",
+  "showInformation",
+]

pyagrum/explain/_explGeneralizedMarkovBlanket.py

@@ -0,0 +1,152 @@
+############################################################################
+#   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.lib._colors as gumcols
+import matplotlib.pyplot as plt
+import pydot as dot
+
+
+def _buildMB(model, x: int, k: int = 1):
+  """
+  Build the nodes and arcs of Markov Blanket (of order k) of node x
+
+  Parameters
+  ----------
+  model: pyagrum.DirectedGraphicalModel
+      i.e. a class with methods parents, children, variable(i), idFromName(name)
+  x : int
+      the nodeId of the node for the Markov blanket
+  k: int
+      the order of the Markov blanket. If k=2, build the MarkovBlanket(MarkovBlanket())
+
+  Returns
+  -------
+      (nodes,arcs,depth) : the set of nodes, the set of arcs of the Markov Blanket and a dict[Str,int] that gives the MB-depth of each node in nodes.
+  """
+  nodes = {x}
+  arcs = set()
+  depth = dict()
+
+  def _internal_build_markov_blanket(bn, x: int, k: int):
+    nodes.add(x)
+    depth[x] = k
+    if k == 0:
+      return
+    for y in bn.parents(x):
+      visit(y, k - 1)
+      arcs.add((y, x))
+    for y in bn.children(x):
+      visit(y, k - 1)
+      arcs.add((x, y))
+      for z in bn.parents(y):
+        visit(z, k - 1)
+        arcs.add((z, y))
+
+  def visit(x, k):
+    if x in nodes and depth[x] >= k:
+      return
+    _internal_build_markov_blanket(model, x, k)
+
+  _internal_build_markov_blanket(model, x, k)
+  return nodes, arcs, depth
+
+
+def generalizedMarkovBlanket(bn, var: int | str, k: int = 1, cmapNode=None):
+  """
+  Build a pydot.Dot representation of the nested Markov Blankets (of order k) of node x
+
+  Warnings
+  --------
+  It is assumed that k<=8. If not, every thing is fine except that the colorscale will change in order to accept more colors.
+
+  Parameters
+  ----------
+  bn: pyagrum.DirectedGraphicalModel
+      i.e. a class with methods parents, children, variable(i), idFromName(name)
+  var : str|int
+      the name or nodeId of the node for the Markov blanket
+  k: int
+      the order of the Markov blanket. If k=1, build the MarkovBlanket(MarkovBlanket())
+  cmap: maplotlib.ColorMap
+      the colormap used (if not, inferno is used)
+
+  Returns
+  -------
+      pydotplus.Dot object
+  """
+  if cmapNode is None:
+    cmapNode = plt.get_cmap("inferno")  # gum.config["notebook", "default_arc_cmap"])
+
+  maxcols = max(
+    8, k
+  )  # It is assumed that k<=8. If not, every thing is fine except that the colorscale will change in order to accept more colors.
+
+  mb = dot.Dot(f"MB({var},{k}", graph_type="digraph", bgcolor="transparent")
+
+  if isinstance(var, str):
+    nx = bn.idFromName(var)
+  else:
+    nx = var
+  nodes, arcs, visited = _buildMB(bn, nx, k)
+  names = dict()
+
+  for n in nodes:
+    protected_name = f'"{bn.variable(n).name()}"'
+    pnode = dot.Node(protected_name, style="filled")
+    if n == var:
+      bgcol = "#99FF99"
+      fgcol = "black"
+    else:
+      bgcol = gumcols.proba2bgcolor(1 - (k - visited[n]) / maxcols, cmapNode)
+      fgcol = gumcols.proba2fgcolor(1 - (k - visited[n]) / maxcols, cmapNode)
+    pnode.set_fillcolor(bgcol)
+    pnode.set_fontcolor(fgcol)
+    mb.add_node(pnode)
+    names[n] = protected_name
+  for n in nodes:
+    for u in bn.parents(n).intersection(nodes):
+      edge = dot.Edge(names[u], names[n])
+      if (u, n) in arcs:
+        edge.set_color("black")
+      else:
+        edge.set_color("#DDDDDD")
+      mb.add_edge(edge)
+
+  return mb

pyagrum/explain/_explIndependenceListForPairs.py

@@ -0,0 +1,146 @@
+############################################################################
+#   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 pylab
+import matplotlib as mpl
+import itertools
+
+
+def _independenceListForPairs(bn, target=None):
+  """
+  returns a list of triples `(i,j,k)` for each non arc `(i,j)` such that `i` is independent of `j` given `k`.
+
+  Parameters
+  ----------
+  bn: gum.BayesNet
+    the Bayesian Network
+
+  target: (optional) str or int
+    the name or id of the target variable. If a target is given, only the independence given a subset of the markov blanket of the target are tested.
+
+  Returns
+  -------
+  List[(str,str,List[str])]
+    A list of independence found in the structure of BN.
+  """
+
+  def powerset(iterable):
+    xs = list(iterable)
+    # note we return an iterator rather than a list
+    return itertools.chain.from_iterable(itertools.combinations(xs, n) for n in range(len(xs) + 1))
+
+  # testing every d-separation
+  l = []
+  nams = sorted(bn.names())
+  if target is None:
+    firstnams = nams.copy()
+    indepnodes = bn.names()
+  else:
+    indepnodes = {bn.variable(i).name() for i in gum.MarkovBlanket(bn, target).nodes()}
+    if isinstance(target, str):
+      firstnams = [target]
+    else:
+      firstnams = [bn.variable(target).name()]
+
+  for i in firstnams:
+    nams.remove(i)
+    for j in nams:
+      if not (bn.existsArc(i, j) or bn.existsArc(j, i)):
+        for k in powerset(sorted(indepnodes - {i, j})):
+          if bn.isIndependent(i, j, k):
+            l.append((i, j, tuple(k)))
+            break
+  return l
+
+
+def independenceListForPairs(bn, filename, target=None, plot=True, alphabetic=False):
+  """
+  get the p-values of the chi2 test of a (as simple as possible) independence proposition for every non arc.
+
+  Parameters
+  ----------
+  bn : gum.BayesNet
+    the Bayesian network
+
+  filename : str
+    the name of the csv database
+
+  alphabetic : bool
+    if True, the list is alphabetically sorted else it is sorted by the p-value
+
+  target: (optional) str or int
+    the name or id of the target variable
+
+  plot : bool
+    if True, plot the result
+
+  Returns
+  -------
+    the list
+  """
+
+  learner = gum.BNLearner(filename, bn)
+  vals = {}
+  for indep in _independenceListForPairs(bn, target):
+    vals[indep] = learner.chi2(*indep)[1]
+
+  if plot:
+    plotvals = dict()
+    for indep in vals:
+      key = "$" + indep[0] + " \\perp " + indep[1]
+      if len(indep[2]) > 0:
+        key += " \\mid " + ",".join(indep[2])
+      key += "$"
+      plotvals[key] = vals[indep]
+
+    if not alphabetic:
+      sortedkeys = sorted(plotvals, key=plotvals.__getitem__, reverse=False)
+    else:
+      sortedkeys = list(plotvals.keys())
+
+    fig = pylab.figure(figsize=(10, 1 + 0.25 * len(plotvals)))
+    ax = fig.add_subplot(1, 1, 1)
+    ax.plot([plotvals[k] for k in sortedkeys], sortedkeys, "o")
+    ax.grid(True)
+    ax.vlines(x=0.05, ymin=-0.5, ymax=len(vals) - 0.5, colors="purple")
+    ax.add_patch(mpl.patches.Rectangle((0, -0.5), 0.05, len(vals), color="yellow"))
+
+  return vals