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

pyagrum/skbn/_MBCalcul.py

@@ -0,0 +1,242 @@
+############################################################################
+#   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 ._utils import _listIdtoName as listIdtoName
+
+
+def compileMarkovBlanket(bn, target):
+  """
+  Create a Bayesian network with the children, their parents and the parents of the node target
+
+  Parameters
+  ----------
+      bn: pyagrum.BayesNet
+          Bayesian network to work on
+      target: str or int
+          Name or id of the target
+  Returns
+  -------
+      MarkovBlanket: pyagrum.BayesNet
+          Markov Blanket from bn
+  """
+  mb = gum.BayesNet("MarkovBlanket")
+
+  # add target to Markov Blanket
+  mb.add(bn.variable(target))
+
+  # list of target's children
+  children = listIdtoName(bn, list(bn.children(target)))
+
+  # list of target's parents
+  parents = listIdtoName(bn, list(bn.parents(target)))
+
+  for c in children:
+    # list of c's parents
+    parents_child = listIdtoName(bn, list(bn.parents(c)))
+
+    # if c is not already in Markov Blanket
+    if c not in mb.names():
+      # add c in Markov Blanket
+      mb.add(bn.variable(c))
+
+      # create arc between target and his child c
+      mb.addArc(target, c)
+
+    # add c's parents in Markov Blanket
+    for pc in parents_child:
+      # if pc is a target's parent
+      if pc in mb.names():
+        if pc != target:
+          mb.addArc(pc, c)
+        continue
+
+      # add pc in Markov Blanket
+      mb.add(bn.variable(pc))
+
+      # if pc is not a children, his cpt doesn't matter (use for predict)
+      if pc not in children:
+        mb.cpt(pc).fillWith(1).normalize()
+      else:
+        mb.addArc(target, pc)
+
+      # create arc between c and his parent pc
+      mb.addArc(pc, c)
+
+  for p in parents:
+    # if p is not already in Markov Blanket
+    if p in mb.names():
+      # create arc between target and his parent p
+      mb.addArc(p, target)
+      continue
+
+    # add p in Markov Blanket
+    mb.add(bn.variable(p))
+
+    # cpt doesn't matter for parents
+    mb.cpt(p).fillWith(1).normalize()
+
+    # create arc between target and his parent p
+    mb.addArc(p, target)
+
+  # update cpt for target and his children
+  mb.cpt(target).fillWith(bn.cpt(target))
+  for i in children:
+    mb.cpt(i).fillWith(bn.cpt(i))
+
+  return mb
+
+
+def _calcul_proba_for_nary_class(row, local_inst, dictName, MarkovBlanket, target):
+  """
+  Calculate the posterior distribution of variable target (given its Markov blanket)
+
+  Parameters
+  ----------
+      row: numpyArray shape: (n features)
+          test data
+      local_inst: pyagrum.Tensor
+          Instantiation of the Markov Blanket EXCEPT the target
+      dictName: Dict[str : int]
+          dictionary of the name of a variable and his column in the data base
+      MarkovBlanket: pyagrum.BayesNet
+          Markov Blanket to work on
+      target: str
+          Name of the target
+  Returns
+  -------
+      proba:
+          the probability distribution for target
+  """
+  # create Instantiation with Markov Blanket's variables
+  for n in MarkovBlanket.names():
+    if n == target:
+      continue
+    local_inst.chgVal(n, str(row[dictName.get(n)]))
+
+  p = MarkovBlanket.cpt(target).extract(local_inst)
+  for i in MarkovBlanket.children(target):
+    p *= MarkovBlanket.cpt(i).extract(local_inst)
+  p.normalize()
+
+  return p
+
+
+def _calcul_most_probable_for_nary_class(row, local_inst, dictName, MarkovBlanket, target):
+  """
+  Calculate the most probable class for variable target
+
+  Parameters
+  ----------
+      row: numpyArray shape: (n features)
+          test data
+      local_inst: pyagrum.Tensor
+          Instantiation of the Markov Blanket EXCEPT the target
+      dictName: Dict[str : int]
+          dictionary of the name of a variable and his column in the data base
+      MarkovBlanket: pyagrum.BayesNet
+          Markov Blanket to work on
+      target: str
+          Name of the target
+  Returns
+  -------
+      Tuple[int,proba]:
+          the value and the probability of the most probable class
+  """
+  p = _calcul_proba_for_nary_class(row, local_inst, dictName, MarkovBlanket, target)
+  return p.argmax(), p.max()
+
+
+def _calcul_proba_for_binary_class(row, label1, labels, Inst, dictName, MarkovBlanket, target):
+  """
+  Calculate the probability of having label1 to the binary variable y
+
+  Parameters
+  ----------
+      row: numpyArray shape: (n features)
+          test data
+      label1:
+          the True value of y
+      labels:
+          the False values of y
+      Inst: Tensor
+          Instantiation of the Markov Blanket
+      dictName: dict[str : int]
+          dictionary of the name of a variable and his column in the data base
+      MarkovBlanket: pyagrum.BayesNet
+          Markov Blanket to work on
+      target: str
+          Name of the target
+  Returns
+  -------
+      double
+          probability of getting label1 to the variable y
+  """
+
+  # create Instantiation with Markov Blanket's variables
+  for n in MarkovBlanket.names():
+    if n == target:
+      continue
+    Inst.chgVal(n, str(row[dictName.get(n)]))
+
+  # probability of Positive value
+  Inst.chgVal(target, str(label1))
+  res1 = MarkovBlanket.cpt(target).get(Inst)
+
+  # probability of Negative value
+  res2 = 0.0
+  for label0 in labels:
+    Inst.chgVal(target, str(label0))
+    res2 += MarkovBlanket.cpt(target).get(Inst)
+
+  # probability for all the children
+  for n in MarkovBlanket.children(target):
+    Inst.chgVal(target, str(label1))
+    res1 = res1 * (MarkovBlanket.cpt(n).get(Inst))
+
+    tmp = 0.0
+    for label0 in labels:
+      Inst.chgVal(target, str(label0))
+      tmp += MarkovBlanket.cpt(n).get(Inst)
+    res2 = res2 * tmp
+
+  # normalize to have probabilities
+
+  return res1 / (res1 + res2)

pyagrum/skbn/__init__.py

@@ -0,0 +1,49 @@
+############################################################################
+#   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, Nikola Matevski, Louise Mouillé"
+__copyright__ = "(c) 2020-2024 PARIS"
+
+from .bnclassifier import BNClassifier
+from ._MBCalcul import compileMarkovBlanket
+
+__all__ = ["BNClassifier", "compileMarkovBlanket"]

pyagrum/skbn/_learningMethods.py

@@ -0,0 +1,282 @@
+############################################################################
+#   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                           #
+#                                                                          #
+############################################################################
+
+"""
+Created on Thu Jun 11 14:08:14 2020
+
+"""
+
+import numpy
+import math
+import warnings
+
+import pyagrum as gum
+
+from ._utils import _ImplementConstraints as implementConstraints
+from ._utils import _ImplementScore as implementScore
+
+
+def _fitStandard(X, y, learner, learningMethod, possibleSkeleton, scoringType, constraints):
+  """
+  The default fit function that uses MIIC, Greedy Hill Climbing or Tabu list sorting depending on the learning method chosen.
+
+  Parameters
+  ---------
+      X: {array-like, sparse matrix} of shape (n_samples, n_features)
+      training data
+      y: array-like of shape (n_samples)
+      Target values
+  """
+
+  implementConstraints(constraints, learner)
+
+  if learningMethod == "MIIC":
+    learner.useMIIC()
+  elif learningMethod == "MIICMDL":
+    learner.useMIIC()
+    learner.useMDLCorrection()
+  elif learningMethod == "MIICNML":
+    learner.useMIIC()
+    learner.useNMLCorrection()
+  elif learningMethod == "GHC":  # default
+    learner.useGreedyHillClimbing()
+  elif learningMethod == "Tabu":
+    learner.useLocalSearchWithTabuList()
+  else:
+    raise ValueError("Learning Method not recognized.")
+
+  if possibleSkeleton is not None:
+    learner.setPossibleSkeleton(possibleSkeleton)
+
+  implementScore(scoringType, learner)
+  bn = learner.learnBN()
+  return bn
+
+
+def _fitTAN(X, y, bn, learner, variableList, target):
+  """
+  Uses Tree-Augmented NaiveBayes to learn the network structure and its parameters.
+
+  Parameters
+  ---------
+      X: {array-like, sparse matrix} of shape (n_samples, n_features)
+      training data
+      y: array-like of shape (n_samples)
+      Target values
+
+  """
+
+  # a list of all the variables in our Bayesian network sorted by their index
+
+  # the number of columns in our data
+  d = X.shape[1]
+
+  # If there is only one input column, TAN works exactly the same as NaiveBayes
+  if d < 2:
+    _fitNaiveBayes(X, y, bn, learner, variableList, target, None)
+    return
+
+  probabilityY = learner.pseudoCount([target]).normalize().tolist()
+  mutualInformation = dict()
+  undirectedGraph = gum.UndiGraph()
+
+  # we calculate the mutual information of all pairs of variables
+  for i in range(d):
+    undirectedGraph.addNodeWithId(i)
+    for j in range(i):
+      probabilityList = learner.pseudoCount([variableList[i], variableList[j], target]).normalize().tolist()
+      probabilityXi = learner.pseudoCount([variableList[i], target]).normalize().tolist()
+      probabilityXj = learner.pseudoCount([variableList[j], target]).normalize().tolist()
+      temp = 0
+      for yIndex in range(len(probabilityList)):
+        for xjIndex in range(len(probabilityList[yIndex])):
+          for xiIndex in range(len(probabilityList[yIndex][xjIndex])):
+            if probabilityList[yIndex][xjIndex][xiIndex] > 0:
+              temp = temp + probabilityList[yIndex][xjIndex][xiIndex] * math.log(
+                probabilityList[yIndex][xjIndex][xiIndex]
+                * probabilityY[yIndex]
+                / (probabilityXi[yIndex][xiIndex] * probabilityXj[yIndex][xjIndex])
+              )
+      mutualInformation[(i, j)] = temp
+  # if the mutual information between two variables is bigger than this threshold, we add an edge between them
+  threshold = 0
+  for var in mutualInformation:
+    threshold = threshold + mutualInformation[var]
+  threshold = float(threshold) / (d * (d - 1))
+
+  mutualInformation = {k: v for k, v in sorted(mutualInformation.items(), key=(lambda item: item[1]), reverse=True)}
+
+  for var in mutualInformation:
+    (i, j) = var
+    # since it's sorted in descending order we know that if this value is under the threshold all the other following values will also be under the threshold
+    if mutualInformation[var] < threshold:
+      break
+    # if the mutual information between xi and xj we add an edge between the two nodes
+    undirectedGraph.addEdge(i, j)
+
+    # if the edge causes a cycle, we delete the edge and pass on to the following pair of variables
+    if undirectedGraph.hasUndirectedCycle():
+      undirectedGraph.eraseEdge(i, j)
+    # dict(int:set(int)): each key is a node from every connected part of the graph. The set associated is a set of all nodes that are part of the same connected part of the graph
+  connectedParts = undirectedGraph.connectedComponents()
+
+  for node in connectedParts:
+    # int: the id of the node that will be used as a root to orient the undirected graph, initialised as 0
+    root = 0
+    # we choose the node with the largest mutual information with y as the root. We save the largest mutual information in the following variable
+    maxMutualInformation = -99999
+    for x0 in connectedParts[node]:
+      mutual = 0
+      probabilityList = learner.pseudoCount([variableList[x0], target]).normalize().tolist()
+      probabilityY = learner.pseudoCount([target]).normalize().tolist()
+      probabilityX = learner.pseudoCount([variableList[x0]]).normalize().tolist()
+      for yIndex in range(len(probabilityList)):
+        for xIndex in range(len(probabilityList[yIndex])):
+          if probabilityList[yIndex][xIndex] > 0:
+            mutual = mutual + probabilityList[yIndex][xIndex] * math.log(
+              probabilityList[yIndex][xIndex] / (probabilityY[yIndex] * probabilityX[xIndex])
+            )
+      if mutual > maxMutualInformation:
+        maxMutualInformation = mutual
+        root = x0
+    ListOfNodes = [root]
+    for tailId in ListOfNodes:
+      # for every element in the list of nodes we create an arc between this element and every neighbour of the element in the undirected graph that is not already in the list of nodes.
+      # Since the graph contains no cycles we know that if headId is already in the list then the arc (headId,tailId) has already been added, meaning the arc (tailId,headId) shouldn't be added
+      neighbours = undirectedGraph.neighbours(tailId)
+      for headId in neighbours:
+        if headId not in ListOfNodes:
+          bn.addArc(variableList[tailId], variableList[headId])
+          ListOfNodes.append(headId)
+  for i in range(d):
+    bn.addArc(target, variableList[i])
+
+  bn = learner.learnParameters(bn.dag())
+  return bn
+
+
+def _fitChowLiu(X, y, bn, learner, variableList, target):
+  """
+  Uses the Chow-Liu algorithm to learn the network structure and its parameters.
+
+  Parameters
+  ---------
+      X: {array-like, sparse matrix} of shape (n_samples, n_features)
+      training data
+      y: array-like of shape (n_samples)
+      Target values
+  """
+
+  # since the chow liu algorithm doesn't differentiate between input and output variables, we construct a matrix that includes them both
+  dimension = y.shape
+  yColumn = numpy.reshape(y, (dimension[0], 1))
+  xAndY = numpy.concatenate((yColumn, X), axis=1)
+  d = xAndY.shape[1]
+
+  mutualInformation = dict()
+  undirectedGraph = gum.UndiGraph()
+
+  # we calculate the mutual information of all pairs of variables
+  for i in range(d):
+    undirectedGraph.addNodeWithId(i)
+    if i > 0:
+      probabilityXi = learner.pseudoCount([variableList[i - 1]]).normalize().tolist()
+    for j in range(i):
+      if j > 0:
+        probabilityList = learner.pseudoCount([variableList[i - 1], variableList[j - 1]]).normalize().tolist()
+        probabilityXj = learner.pseudoCount([variableList[j - 1]]).normalize().tolist()
+      else:
+        probabilityList = learner.pseudoCount([variableList[i - 1], target]).normalize().tolist()
+        probabilityXj = learner.pseudoCount([target]).normalize().tolist()
+      mutual = 0
+      for xjIndex in range(len(probabilityList)):
+        for xiIndex in range(len(probabilityList[xjIndex])):
+          if probabilityList[xjIndex][xiIndex] > 0:
+            mutual = mutual + probabilityList[xjIndex][xiIndex] * math.log(
+              probabilityList[xjIndex][xiIndex] / (probabilityXi[xiIndex] * probabilityXj[xjIndex])
+            )
+      mutualInformation[(i, j)] = mutual
+  # sorting the dictionary of mutualInformation in descending order by the values associated
+  mutualInformation = {k: v for k, v in sorted(mutualInformation.items(), key=(lambda item: item[1]), reverse=True)}
+
+  for i, j in mutualInformation:
+    # if the mutual information between xi and xj we add an edge between the two nodes
+    undirectedGraph.addEdge(i, j)
+
+    # if the edge causes a cycle, we delete the edge and pass on to the following pair of variables
+    if undirectedGraph.hasUndirectedCycle():
+      undirectedGraph.eraseEdge(i, j)
+
+  ListOfNodes = [0]
+  for tailId in ListOfNodes:
+    # for every element in the list of nodes we create an arc between this element and every neighbour of the element in the undirected graph that is not already in the list of nodes.
+    # Since the graph contains no cycles we know that if headId is already in the list then the arc (headId,tailId) has already been added, meaning the arc (tailId,headId) shouldn't be added
+    neighbours = undirectedGraph.neighbours(tailId)
+    for headId in neighbours:
+      if headId not in ListOfNodes:
+        if tailId > 0:
+          bn.addArc(variableList[tailId - 1], variableList[headId - 1])
+        else:
+          bn.addArc(target, variableList[headId - 1])
+        ListOfNodes.append(headId)
+
+  bn = learner.learnParameters(bn.dag())
+  return bn
+
+
+def _fitNaiveBayes(X, y, bn, learner, variableList, target, constraints):
+  """
+  Uses the Naive Bayes algorithm to learn the network parameters. The network structure isn't learned since it is fixed.
+
+  Parameters
+  ---------
+      X: {array-like, sparse matrix} of shape (n_samples, n_features)
+      training data
+      y: array-like of shape (n_samples)
+      Target values
+  """
+
+  for variableName in variableList:
+    bn.addArc(target, variableName)
+  if constraints is not None:
+    warnings.warn("The structure of Naive Bayes is fixed, so it is impossible to add any new constraints")
+
+  bn = learner.learnParameters(bn.dag())
+  return bn