pyAgrum-nightly 2.2.1.9.dev202510261761405498__cp310-abi3-manylinux2014_aarch64.whl → 2.3.0.9.dev202510281761586496__cp310-abi3-manylinux2014_aarch64.whl

pyagrum/lib/explain.py

@@ -42,495 +42,16 @@
 tools for BN qualitative analysis and explainability
 """
 
-import itertools
 import warnings
-from typing import Union
 
-import pylab
-import pydot as dot
-
-import matplotlib as mpl
-import matplotlib.pyplot as plt
-
-import pyagrum as gum
-from pyagrum.lib.bn2graph import BN2dot
-import pyagrum.lib._colors as gumcols
-
-# importing ShapValues in the name space of explain
-# ruff: noqa: F401
-from pyagrum.lib.shapley import ShapValues
-
-_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 _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
-
-
-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)
-
-
-########################## MB(k) #####################################
-
-
-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: Union[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
-
-
-def generalizedMarkovBlanketNames(bn, var: Union[int, str], depth: int = 1):
-  """
-  List the name of all nodes in the nested Markov Blankets (of order k) in association with their depth
-
-  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
-  depth: int
-      the order of the Markov blanket. If k=1, build the MarkovBlanket(MarkovBlanket()
-
-  Returns
-  -------
-  Dict[str,int]
-    the list of names and their depth.
-  """
-  if isinstance(var, str):
-    nx = bn.idFromName(var)
-  else:
-    nx = var
-  nodes, _, visited = _buildMB(bn, nx, depth)
-  return {bn.variable(node).name(): depth - visited[node] for node in nodes}
-
-
-def showShapValues(bn, shaps, cmap="plasma") -> None:
-  """
-  Show the Shap values in the DAG of the BN
-
-  Parameters
-  ----------
-  bn : pyagrum.BayesNet
-    The Bayesian network
-  shaps: dict[str,float]
-    The (Shap) values to each variable
-  cmap: Matplotlib.ColorMap
-    The colormap used for coloring the nodes
-  """
-  import pyagrum.lib.shapley as shapley
-  import pyagrum.lib.notebook as gnb
-
-  g = shapley.getShapValues(bn, shaps, cmap)
-  gnb.showGraph(g)
+warnings.warn(
+  "The module 'pyagrum.lib.explain' has been deprecated since version 2.2.2. "
+  "Please use the 'pyagrum.explain' module instead.",
+  DeprecationWarning,
+  stacklevel=2,
+)
+
+from pyagrum.explain.shapley import ShapValues  # noqa: E402
+from pyagrum.explain.notebook import showShapValues  # noqa: E402
+from pyagrum.explain import independenceListForPairs  # noqa: E402
+from pyagrum.explain import showInformation, getInformation, getInformationGraph  # noqa: E402

pyagrum/pyagrum.py

@@ -4068,6 +4068,9 @@ class DAG(DiGraph):
     def moralGraph(self) -> "pyagrum.UndiGraph":
         return _pyagrum.DAG_moralGraph(self)
 
+    def minimalCondSet(self, *args) -> List[int]:
+        return _pyagrum.DAG_minimalCondSet(self, *args)
+
     def __repr__(self) -> str:
         return _pyagrum.DAG___repr__(self)
 
@@ -6648,6 +6651,9 @@ class DAGmodel(GraphicalModel):
         """
         return _pyagrum.DAGmodel_hasSameStructure(self, other)
 
+    def minimalCondSet(self, *args) -> List[int]:
+        return _pyagrum.DAGmodel_minimalCondSet(self, *args)
+
 # Register DAGmodel in _pyagrum:
 _pyagrum.DAGmodel_swigregister(DAGmodel)
 class UGmodel(GraphicalModel):
@@ -11792,19 +11798,20 @@ class BayesNet(IBayesNet):
             - the structure 'a->b->c;b->d<-e;'.
             - the type of the variables with different syntax:
 
-              - by default, a variable is a pyagrum.RangeVariable using the default domain size ([2])
-              - with 'a[10]', the variable is a pyagrum.RangeVariable using 10 as domain size (from 0 to 9)
-              - with 'a[3,7]', the variable is a pyagrum.RangeVariable using a domainSize from 3 to 7
-              - with 'a[1,3.14,5,6.2]', the variable is a pyagrum.DiscretizedVariable using the given ticks (at least 3 values)
-              - with 'a{top|middle|bottom}', the variable is a pyagrum.LabelizedVariable using the given labels.
-              - with 'a{-1|5|0|3}', the variable is a pyagrum.IntegerVariable using the sorted given values.
-              - with 'a{-0.5|5.01|0|3.1415}', the variable is a pyagrum.NumericalDiscreteVariable using the sorted given values.
+              - by default, a variable is a binary `pyagrum.RangeVariable` using the default domain size ([2])
+              - with 'a[10]', the variable is a `pyagrum.RangeVariable` using 10 as domain size (from 0 to 9)
+              - with 'a[3,7]', the variable is a `pyagrum.RangeVariable` using a domainSize from 3 to 7
+              - with 'a[1,3.14,5,6.2]', the variable is a `pyagrum.DiscretizedVariable` using the given ticks (at least 3 values)
+              - with 'a[0.0:3.14:10]', the variable is a `pyagrum.DiscretizedVariable` of 10 intervals of same width from 0 to 3.14 (including both)
+              - with 'a{top|middle|bottom}', the variable is a `pyagrum.LabelizedVariable` using the given labels.
+              - with 'a{-1|5|0|3}', the variable is a `pyagrum.IntegerVariable` using the sorted given values.
+              - with 'a{-0.5|5.01|0|3.1415}', the variable is a `pyagrum.NumericalDiscreteVariable` using the sorted given values.
 
         Note
         ----
           - If the dot-like string contains such a specification more than once for a variable, the first specification will be used.
           - the CPTs are randomly generated.
-          - see also pyagrum.fastBN.
+          - see also the function pyagrum.fastBN.
 
         Examples
         --------
@@ -29542,7 +29549,7 @@ class ShaferShenoyLIMIDInference(object):
 
 # Register ShaferShenoyLIMIDInference in _pyagrum:
 _pyagrum.ShaferShenoyLIMIDInference_swigregister(ShaferShenoyLIMIDInference)
-__version__ = '2.2.1.9'
+__version__ = '2.3.0.9'
 __license__ = __doc__
 __project_url__ = 'https://agrum.org'
 __project_name__ = 'pyAgrum'
@@ -31424,7 +31431,7 @@ def getPosterior(model, *, target, evs=None):
 # creating a new Tensor from posterior(will disappear with ie)
   return pyagrum.Tensor(inf.posterior(target))
 
-__version__ = '2.2.1.9'
+__version__ = '2.3.0.9'
 __license__ = __doc__
 __project_url__ = 'https://agrum.org'
 __project_name__ = 'pyAgrum'

{pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info → pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyAgrum-nightly
-Version: 2.2.1.9.dev202510261761405498
+Version: 2.3.0.9.dev202510281761586496
 Summary: Bayesian networks and other Probabilistic Graphical Models.
 Home-page: https://agrum.gitlab.io/
 Author: Pierre-Henri Wuillemin and Christophe Gonzales

{pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info → pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info}/RECORD

@@ -1,10 +1,15 @@
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/METADATA,sha256=pv6STz7B1urUT84qZlZq30rEvjsndU6t4utIHQygOm0,5359
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/LICENSE.md,sha256=HYT-rEPDlbvyRsKwEEFLHgv9Dw70nNhZgdl06P_dcmg,911
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/WHEEL,sha256=1rT9lggu32BbulFEcayIEX3TWTTdT-aJD4MjgYTYeDg,101
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/LICENSES/LGPL-3.0-or-later.txt,sha256=mWrwUT3yH3SWKIlRxBQooDwXTp5KnWNmXFfWcPhFzLE,42098
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/LICENSES/MIT.txt,sha256=sFeF-fGOZxa6tjQksRRUUTuZQ6IiWVtwQRAJIC_FkrU,1078
 pyagrum/__init__.py,sha256=oQraSyGryVUjqi5C1K622cZzs4ETa1QSH9OKmYsd6G0,7458
-pyagrum/common.py,sha256=_kKR8NaXUOXX3LlSo4nM7g6Iq6UNWh7PITqA2uae6_c,3563
+pyagrum/common.py,sha256=8ZKYYMUd4g6eL9Qs5j6HRVrrE6Oc78x5fuCv7b27VtY,3563
 pyagrum/defaults.ini,sha256=AoKPBdH8b-6az9Er_0xZfjjH3g8xUfDIWpAmOb8nICY,4668
-pyagrum/_pyagrum.so,sha256=0FQ_9Gi-Wv3t3JypyRY-KyfklAr1eZWIPajkH6aXR7g,16911992
+pyagrum/_pyagrum.so,sha256=tw7vJn1an-fFXvbHBrs7EON1umIc7IMWgAvwVqX8HqI,17133304
 pyagrum/deprecated.py,sha256=-c9PC_Nmzmx7yuYN9JfGeR-XiaNjQ8t4L6uM9vrRShw,4170
-pyagrum/config.py,sha256=Wlvgzo3z19dQLJPBiJ1mQKCROpnaek4MBSTY_np7jlI,11266
-pyagrum/pyagrum.py,sha256=llF97llnr3v8hKOu7aSLjKxVhOPBdCWp68dfAR-whn0,836669
+pyagrum/config.py,sha256=2t0LHuuPilYZvEPSV0Yy5C5U71ZLzZlee5K_jblxSkg,11296
+pyagrum/pyagrum.py,sha256=kgCWBWqGx3QSYnKv9EGkvqly_dKaE91OBW9o-Xsa4P0,837071
 pyagrum/clg/__init__.py,sha256=BoHyxhPUI21b0rAMqgOvkPpLW0HUA49DbZdBq2X-azI,3530
 pyagrum/clg/SEM.py,sha256=TobJciPi8p0CiMK6OtyX785djKe9Uc-d2pD4a8j33XU,9583
 pyagrum/clg/notebook.py,sha256=PmcxnpwEfZ1mjy0fN33ykhF2Qg8i50xVsffRmbcQe8I,14686
@@ -40,12 +45,11 @@ pyagrum/bnmixture/notebook.py,sha256=lZ4yiIRkC5zCz-lREA1KpyB8e52unsZF8tdxLvtXjRQ
 pyagrum/bnmixture/BNMixture.py,sha256=zFj7S3KZ5601Ct-1TAWTbLnknJic78-IQB0RstZWL04,14620
 pyagrum/bnmixture/BNMLearning.py,sha256=kGumPSWaE54DCtr_iRO0qLPxl-d_WEPkTxlWsAaflCk,13519
 pyagrum/bnmixture/BNMInference.py,sha256=fl2kRaedTY5Hw2PJLPVPdSqizB04SjrJys5WtWZFPRc,9551
-pyagrum/lib/shapley.py,sha256=8W3uDAaaq4rP0w008PGMC8T4TTmnFi_NAvTiy3gYKxE,23340
 pyagrum/lib/discretizer.py,sha256=bEDpe-qh4QzBAk1CIiqyaU6Y1efyTYJ-iRdtFd2pCdY,3568
 pyagrum/lib/bn2graph.py,sha256=_sOxhytd-_TZ6CbjVEUVNH56PqiIzW1kWv6YLiaspxo,10730
 pyagrum/lib/__init__.py,sha256=RTCREcD0gHVEsW-l3T7zvWiDlH6hy6uZX0OMT9n1O6c,3139
 pyagrum/lib/dynamicBN.py,sha256=u9a-eAma_aBF7rrJe9Z9NDj_74tZQowMRt_K1AXrx84,12647
-pyagrum/lib/explain.py,sha256=hVlo-QCKD8f3Vzm4SNYQZK4D8jGuzDaiQLUYnCQcX2E,16468
+pyagrum/lib/explain.py,sha256=lIaXqwOdZePvDWkz5YvtoktmsAL3zAYejh1v845eZxs,3561
 pyagrum/lib/discreteTypeProcessor.py,sha256=jnkb66veIddzT9etK0Bgdnpa6Y1dvohdtUCHmq7PaTs,47176
 pyagrum/lib/bn2roc.py,sha256=xwaJ96kUjRybhqS1sj-jWWQK-AUmf3T-t_iScYJ-Bcs,27173
 pyagrum/lib/notebook.py,sha256=qzVAMks1J2imPexIyvcQpa8hFZl19NsOstTleRTDOLc,52855
@@ -75,9 +79,29 @@ pyagrum/ctbn/notebook.py,sha256=Hlzv1UcrJTqp4BZR1pAjkl6y7u8zW2v21mKKjkTYVDA,9253
 pyagrum/ctbn/constants.py,sha256=jTbwEGttp6hcGfrvk0tOoFn3rm4xsMHNcTusjMJtppQ,3282
 pyagrum/ctbn/CTBNLearner.py,sha256=2T4Lp7jKngcX-SIHAJFCj8sBSItqSofj1yNqhi73h7w,6591
 pyagrum/ctbn/CTBN.py,sha256=5eA6DJbZwQ_6QatuGiW_PDPcd_zk1WdUBk3Ata_gndg,15558
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/METADATA,sha256=vnzvFzmRQBnduxAVYDx8RXbAQQ0t_X-5bAgfL2zDKCw,5359
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/LICENSE.md,sha256=HYT-rEPDlbvyRsKwEEFLHgv9Dw70nNhZgdl06P_dcmg,911
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/WHEEL,sha256=1rT9lggu32BbulFEcayIEX3TWTTdT-aJD4MjgYTYeDg,101
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/LICENSES/LGPL-3.0-or-later.txt,sha256=mWrwUT3yH3SWKIlRxBQooDwXTp5KnWNmXFfWcPhFzLE,42098
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/LICENSES/MIT.txt,sha256=sFeF-fGOZxa6tjQksRRUUTuZQ6IiWVtwQRAJIC_FkrU,1078
-pyagrum_nightly-2.2.1.9.dev202510261761405498.dist-info/RECORD,,
+pyagrum/explain/_explIndependenceListForPairs.py,sha256=-CU8SK_rGDhpWkK1-eMivyFmXWdzOZjICV4Yu8t97dY,5927
+pyagrum/explain/shapley.py,sha256=qvPqJ_Dj8IzmvyGC_K-e3X174nseqSo1OY4FneGvpVI,9848
+pyagrum/explain/_ShapCausalValues.py,sha256=GXByLHySEO0GYl5zn0TuL9DPQmfi4t5pRDpSSPK3Ua4,10425
+pyagrum/explain/_ShapConditionalValues.py,sha256=NGAURiCLVVx_J3uv-oN_Dp1fg6UKpSRRFYKkEPpII8k,6923
+pyagrum/explain/_ComputationConditional.py,sha256=l3r5OeZ5Bnc_qhVtYf4XHlJcNjWr7npIBNsaocR0cdo,3214
+pyagrum/explain/__init__.py,sha256=sJDh0Mhjpyq1bE6IJ93q41d1v5_OnNzrk5asvqwbcqw,4219
+pyagrum/explain/_CustomShapleyCache.py,sha256=6p-qiN4gT26IbiQ24IgybQOL6jzPULXwzbmbYRv0NwY,5656
+pyagrum/explain/_explInformationGraph.py,sha256=MIVmmqssYqSx3fdhtSsbLP8kphSddyxTtgIcle3odFA,8862
+pyagrum/explain/_ShallCausalValues.py,sha256=WnBf-p7mzbxL-QFb13Dw-bOtrdA9jpOfeMaiJHzUOVk,9217
+pyagrum/explain/_ShallValues.py,sha256=rIOOXLUOufvIIGxULoqo106OcROGPrUmJx9xchykm3Q,14026
+pyagrum/explain/_Explanation.py,sha256=Q7KFKWx95x8Th4tpzGUptrMWGXZ8c3zKmGPBfshLdBA,3752
+pyagrum/explain/_ComputationMarginal.py,sha256=b4BIr97nn-A5ocbolfufmR9zk-rHA_AmSx0i4zj9Vks,3211
+pyagrum/explain/_ShapleyValues.py,sha256=hEQAwu6sNf4--opcvZiwS90ztH4UOAgl_4l_kFQFouU,12634
+pyagrum/explain/_explGeneralizedMarkovBlanket.py,sha256=1r7NmQvanFAawRKRDX1TpoO0cQcNJRSCA6iClnQu_Vk,6250
+pyagrum/explain/_FIFOCache.py,sha256=dD-YH7ZU8WQuWNbHDxSWsnnxN1Ml5ttTXQgnT8z5B78,3418
+pyagrum/explain/_Explainer.py,sha256=mwIoMwHMUwrtXy15DuxYaKFkDeBDaKL-QQCuBYJnQdI,7421
+pyagrum/explain/_ShallMarginalValues.py,sha256=TsoCqujkwz6bhKxBqnpfrqnRpFCm2ttdTywjZiopkOU,7157
+pyagrum/explain/_ComputationCausal.py,sha256=qBEoXUM60xgsAJmKyjikyf6GER6KYSxWUxCyM5wpWUk,4287
+pyagrum/explain/_ShallConditionalValues.py,sha256=IIau9cUYm4DuKfTy3AMvDgWSmZsU1vYMBnDuGgk_gUM,7854
+pyagrum/explain/_ShapMarginalValues.py,sha256=cIBIBStE7lC67AYCPjOZDzMnb1qq0iQQ5GdGa4SsBBo,9527
+pyagrum/explain/notebook/_beeswarm.py,sha256=6RfoV57i-ZkLC0avZcciL1xasHt0hIxivt6nC4nRUIM,7927
+pyagrum/explain/notebook/__init__.py,sha256=yHxm2WsI62HbKRcDtPCPX3biXYYO-3w2oaHF2fIFeY4,3286
+pyagrum/explain/notebook/_bar.py,sha256=l6ywdj3abo1LvevqybngsjT8vd2GfUKToFv7MemnD60,7340
+pyagrum/explain/notebook/_waterfall.py,sha256=WwP6Y8fwglIG1tcvR2DrTuhTGgDa9tO0Dyfs3uHLgwM,8924
+pyagrum/explain/notebook/_showShapValues.py,sha256=jhUShbolBpHFqajD1Z3fzEkUgsjh56vgyQpVskIiFWc,4884
+pyagrum_nightly-2.3.0.9.dev202510281761586496.dist-info/RECORD,,