pyAgrum-nightly 2.1.1.9.dev202506061747485979__cp310-abi3-manylinux2014_aarch64.whl → 2.3.1.9.dev202601031765915415__cp310-abi3-manylinux2014_aarch64.whl

pyagrum/pyagrum.py

@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.2.1
+# Version 4.3.1
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.
@@ -1505,9 +1505,47 @@ class DiscreteVariable(Variable):
         return _pyagrum.DiscreteVariable_isEmpirical(self)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.DiscreteVariable_closestIndex(self, val)
 
     def closestLabel(self, val: float) -> str:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        str
+          the label of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.InvalidArgument
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.DiscreteVariable_closestLabel(self, val)
 
     def varType(self) -> int:
@@ -1983,6 +2021,25 @@ class LabelizedVariable(DiscreteVariable):
         return _pyagrum.LabelizedVariable_numerical(self, index)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.LabelizedVariable_closestIndex(self, val)
 
     def domainSize(self) -> int:
@@ -2257,6 +2314,25 @@ class RangeVariable(DiscreteVariable):
         return _pyagrum.RangeVariable_index(self, arg2)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.RangeVariable_closestIndex(self, val)
 
     def domain(self) -> str:
@@ -2387,6 +2463,25 @@ class IntegerVariable(DiscreteVariable):
         return _pyagrum.IntegerVariable_index(self, label)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.IntegerVariable_closestIndex(self, val)
 
     def label(self, index: int) -> str:
@@ -2533,6 +2628,25 @@ class IntegerVariable(DiscreteVariable):
         return _pyagrum.IntegerVariable_eraseValues(self)
 
     def closestLabel(self, val: float) -> str:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        str
+          the label of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.InvalidArgument
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.IntegerVariable_closestLabel(self, val)
 
     def __repr__(self) -> str:
@@ -2652,6 +2766,25 @@ class NumericalDiscreteVariable(DiscreteVariable):
         return _pyagrum.NumericalDiscreteVariable_index(self, label)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.NumericalDiscreteVariable_closestIndex(self, val)
 
     def label(self, index: int) -> str:
@@ -2798,6 +2931,25 @@ class NumericalDiscreteVariable(DiscreteVariable):
         return _pyagrum.NumericalDiscreteVariable_eraseValues(self)
 
     def closestLabel(self, val: float) -> str:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the label of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        str
+          the label of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.InvalidArgument
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.NumericalDiscreteVariable_closestLabel(self, val)
 
     def __repr__(self) -> str:
@@ -3916,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)
 
@@ -3923,9 +4078,41 @@ class DAG(DiGraph):
         return _pyagrum.DAG___str__(self)
 
     def dSeparation(self, *args) -> bool:
+        r"""
+
+        Check if the sets of nodes X and Y are d-separated (by the set of nodes Z if given) in the DAG.
+
+        Parameters
+        ----------
+        X : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Y : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Z : int sequence of int (optional)
+          a sequence of node ids (int) or a single node id (int)
+        Returns
+        -------
+        bool
+          True if X and Y are d-separated (by Z if given), False otherwise.
+
+        """
         return _pyagrum.DAG_dSeparation(self, *args)
 
     def moralizedAncestralGraph(self, *args) -> "pyagrum.UndiGraph":
+        r"""
+
+        Compute the moralized ancestral graph of the nodes from the DAG.
+
+        Parameters
+        ----------
+        nodes : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Returns
+        ------- 
+        "pyagrum.UndiGraph"
+          the moralized ancestral graph of the nodes from the DAG.
+
+        """
         return _pyagrum.DAG_moralizedAncestralGraph(self, *args)
 
     def addNodes(self, n: int) -> object:
@@ -4631,9 +4818,41 @@ class PDAG(MixedGraph):
         return _pyagrum.PDAG___str__(self)
 
     def cSeparation(self, *args) -> bool:
+        r"""
+
+        Check if the sets of nodes X and Y are c-separated (by the set of nodes Z if given) in the PDAG.
+
+        Parameters
+        ----------
+        X : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Y : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Z : int sequence of int (optional)
+          a sequence of node ids (int) or a single node id (int)
+        Returns
+        -------
+        bool
+          True if X and Y are c-separated (by Z if given), False otherwise.
+
+        """
         return _pyagrum.PDAG_cSeparation(self, *args)
 
     def moralizedAncestralGraph(self, *args) -> "pyagrum.UndiGraph":
+        r"""
+
+        Compute the moralized ancestral graph of the nodes from the DAG.
+
+        Parameters
+        ----------
+        nodes : int sequence of int
+          a sequence of node ids (int) or a single node id (int)
+        Returns
+        ------- 
+        "pyagrum.UndiGraph"
+          the moralized ancestral graph of the nodes from the DAG.
+
+        """
         return _pyagrum.PDAG_moralizedAncestralGraph(self, *args)
 
     def addNodes(self, n: int) -> object:
@@ -6432,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):
@@ -7215,6 +7437,25 @@ class DiscretizedVariable(IDiscretizedVariable):
         return _pyagrum.DiscretizedVariable_ticks(self)
 
     def closestIndex(self, val: float) -> int:
+        r"""
+
+        For numerical discrete variables (all except :class:`pyagrum.LabelizedVariable`), this method returns the index of the closest value to a given float value in the variable's domain.
+
+        Parameters
+        ----------
+        value : float
+          the value for which we want to find the closest index
+        Returns
+        -------
+        int
+          the index of the closest value to `value` in the variable's domain
+
+        Raises
+        ------
+        pyagrum.NotImplementedYet
+          if the variable is not numerical discrete (i.e., if it is a :class:`pyagrum.LabelizedVariable`).
+
+        """
         return _pyagrum.DiscretizedVariable_closestIndex(self, val)
 
     def toFast(self) -> str:
@@ -7308,6 +7549,23 @@ class Tensor(object):
 
     @staticmethod
     def deterministicTensor(*args) -> "pyagrum.Tensor":
+        r"""
+
+        This static method generates a Tensor representing a deterministic function of a :class:`pyagrum.DiscreteVariable`) such as a hard evidence.
+
+        Parameters
+        ----------
+        var : pyagrum.DiscreteVariable
+          the variable to use
+        value: int str
+          the indice or the label of the value for the variable
+
+        Returns
+        -------
+        pyagrum.Tensor
+          The representation of the deterministic function as a :class:`pyagrum.Tensor`.
+
+        """
         return _pyagrum.Tensor_deterministicTensor(*args)
 
     @staticmethod
@@ -7433,6 +7691,21 @@ class Tensor(object):
         return _pyagrum.Tensor_minNonZero(self)
 
     def findAll(self, v: float) -> List[Dict[str,int]]:
+        r"""
+
+        Find all the position of a value in the Tensor.
+
+        Parameters
+        ----------
+        v : float
+          the value to find
+
+        Returns
+        -------
+        list[dict[str,int]]
+          a list of all the instantiations (as python dictionary) where the value is found
+
+        """
         return _pyagrum.Tensor_findAll(self, v)
 
     def entropy(self) -> float:
@@ -7861,7 +8134,7 @@ class Tensor(object):
 
         Returns
         -------
-        pyAgrum.Te nsor
+        pyAgrum.Tensor
           The representation of the evidence as a :class:`~pyagrum.Tensor`.
 
         """
@@ -8806,6 +9079,16 @@ class Tensor(object):
 
 
     def domainSize(self) -> int:
+        r"""
+
+        Compute the size of the domain of the Tensor, i.e., the product of the domain sizes of the variables in the Tensor.
+
+        Returns
+        -------
+        int
+          the size of the domain of the Tensor (the number of values it can take) 
+
+        """
         return _pyagrum.Tensor_domainSize(self)
 
     def nbrDim(self, *args) -> int:
@@ -9428,6 +9711,9 @@ class InformationTheory(object):
 
 # Register InformationTheory in _pyagrum:
 _pyagrum.InformationTheory_swigregister(InformationTheory)
+
+import warnings
+
 class PRMexplorer(object):
     r"""
 
@@ -11512,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
         --------
@@ -24223,12 +24510,12 @@ class BNLearner(object):
     def learnBN(self) -> "pyagrum.BayesNet":
         r"""
 
-        learn a BayesNet from a file (must have read the db before)
+        Learns a BayesNet (both parameters and structure) from the BNLearner's database
 
         Returns
         -------
         pyagrum.BayesNet
-        	the learned BayesNet
+        	the learnt BayesNet
 
         """
         return _pyagrum.BNLearner_learnBN(self)
@@ -24236,42 +24523,83 @@ class BNLearner(object):
     def learnParameters(self, *args) -> "pyagrum.BayesNet":
         r"""
 
-        Create a new BN copying its structure from the argument (dag or BN) and learning its parameters from the database w.r.t the BNLearner's state (priors, etc.).
+        Creates a Bayes net whose structure corresponds to that passed in argument or to
+        the last structure learnt by Method `learnDAG()`, and whose parameters are learnt
+        from the BNLearner's database.
 
-        Warnings
-        --------
-        When using a `pyagrum.DAG` as input parameter, NodeIds in the dag and index of rows in the database must fit in order to coherently fix the structure of the BN.
-        Generally, it is safer to use a `pyagrum.BayesianNet` as input or even to use `pyagrum.BNLearner.fitParameters`.
+        usage:
+          1. `learnParameters(dag, take_into_account_score=True)`
+          2. `learnParameters(bn, take_into_account_score=True)`
+          3. `learnParameters(take_into_account_score=True)`
+
+        When the first argument of Method `learnParameters()` is a DAG or a Bayes net
+        (usages 1. and 2.), this one specifies the graphical structure of the returned
+        Bayes net. Otherwise (usage 3.), Method `learnParameters()` is called implicitly
+        with the last DAG learnt by the BNLearner.
+
+        The difference between calling this method with a DAG (usages 1. and 3.) or a
+        Bayes net (usage 2.) arises when the database contains missing values and EM is
+        used to learn the parameters. EM needs to initialize the conditional probability
+        distributions (CPT) before iterating the expectation/maximimzation steps. When a
+        DAG is passed in argument, these initializations are performed using a specific
+        estimator that does not take into account the missing values in the database. The
+        resulting CPTs are then perturbed randomly (see the noise in method `useEM()`).
+        When a Bayes net is passed in argument, its CPT for a node A can be either filled
+        exclusively with zeroes or not. In the first case, the initialization is performed
+        as described above. In the second case, the value of A's CPT is used as is, and
+        a subsequent perturbation controlled by the noise level is applied.
 
         Parameters
         ----------
         dag : pyagrum.DAG
+        	specifies the graphical structure of the returned Bayes net.
         bn : pyagrum.BayesNet
-        take_into_account_score : bool
-        	The dag passed in argument may have been learnt from a structure learning. In this case, if the score used to learn the structure has an implicit prior (like K2 which has a 1-smoothing prior), it is important to also take into account this implicit prior for parameter learning. By default (`take_into_account_score=True`), we will learn parameters by taking into account the prior specified by methods usePriorXXX () + the implicit prior of the score (if any). If `take_into_account_score=False`, we just take into account the prior specified by `usePriorXXX()`.
+        	specifies the graphical structure of the returned Bayes net and, when
+        	the database contains missing values and EM is used for learning, force
+        	EM to initialize the CPTs of the resulting Bayes net to the values of
+        	those passed in argument (when they are not fully filled with zeroes)
+        	before iterating over the expectation/maximization steps.
+        take_into_account_score : bool, default=True
+        	The graphical structure passed in argument may have been learnt from a
+        	structure learning. In this case, if the score used to learn the structure
+        	has an implicit prior (like K2 which has a 1-smoothing prior), it is important
+        	to also take into account this implicit prior for parameter learning. By
+        	default (`take_into_account_score=True`), we will learn parameters by taking
+        	into account the prior specified by methods usePriorXXX() + the implicit prior
+        	of the score (if any). If `take_into_account_score=False`, we just take into
+        	account the prior specified by `usePriorXXX()`.
 
         Returns
         -------
         pyagrum.BayesNet
-        	the learned BayesNet
+        	the learnt BayesNet
 
         Raises
         ------
         pyagrum.MissingVariableInDatabase
-        	If a variable of the BN is not found in the database
+        	If a variable of the Bayes net is not found in the database
+        pyagrum.MissingValueInDatabase
+        	If the database contains some missing values and EM is not used for the learning
+        pyagrum.OperationNotAllowed
+        	If EM is used but no stopping criterion has been selected
         pyagrum.UnknownLabelInDatabase
         	If a label is found in the database that do not correspond to the variable
 
-        """
+        Warnings
+        --------
+        When using a `pyagrum.DAG` as input parameter, the NodeIds in the dag and index of
+        rows in the database must fit in order to coherently fix the structure of the BN.
+        Generally, it is safer to use a `pyagrum.BayesNet` as input or even to use
+        `pyagrum.BNLearner.fitParameters`.
 
-        if type(args[0])==pyagrum.BayesNet:
-            res=pyagrum.BayesNet(args[0])
-            self.fitParameters(res)
-            return res
+        """
+        val = _pyagrum.BNLearner_learnParameters(self, *args)
 
+        if self._EM_warning():
+            warnings.warn("\nthe learnParameters's EM algorithm has completed prematurely due to a likelihood divergence\n", UserWarning)
 
 
-        return _pyagrum.BNLearner_learnParameters(self, *args)
+        return val
 
 
     def copyState(self, learner: "BNLearner") -> None:
@@ -24296,6 +24624,8 @@ class BNLearner(object):
     def setInitialDAG(self, dag: "pyagrum.DAG") -> "pyagrum.BNLearner":
         r"""
 
+        Sets the initial structure (DAG) used by the structure learning algorithm.
+
         Parameters
         ----------
         dag : pyagrum.DAG
@@ -24304,56 +24634,407 @@ class BNLearner(object):
         """
         return _pyagrum.BNLearner_setInitialDAG(self, dag)
 
-    def useEM(self, epsilon: float) -> "pyagrum.BNLearner":
+    def useEM(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Indicates if we use EM for parameter learning.
+        Sets whether we use EM for parameter learning or not, depending on the value of epsilon.
+
+        usage:
+          * `useEM(epsilon, noise=0.1)`
+
+        When epsilon is equal to 0.0, EM is forbidden, else EM is used for parameter learning
+        whenever the database contains missing values. In this case, its stopping criterion
+        is a threshold on the log-likelihood evolution rate, i.e., if llc and llo refer to
+        the log-likelihoods at the current and previous EM steps respectively, EM will stop
+        when (llc - llo) / llc drops below epsilon. If you wish to be more specific on which
+        stopping criterion to use, you may prefer exploiting methods `useEMWithRateCriterion()`
+        or `useEMWithDiffCriterion()`.
 
         Parameters
         ----------
         epsilon : float
-        	if epsilon=0.0 then EM is not used.
-        	if epsilon>0 then EM is used and stops when the sum of the cumulative squared error on parameters is less than epsilon.
-
-        """
-        return _pyagrum.BNLearner_useEM(self, epsilon)
+        	if epsilon>0 then EM is used and stops whenever the relative difference between two
+        	consecutive log-likelihoods (log-likelihood evolution rate) drops below epsilon.
 
-    def useScoreAIC(self) -> "pyagrum.BNLearner":
-        r"""
-
-        Indicate that we wish to use an AIC score.
+        	if epsilon=0.0 then EM is not used. But if you wish to forbid the use of EM, prefer
+        	executing Method `forbidEM()` rather than useEM(0.0) as it is more unequivocal.
 
-        """
-        return _pyagrum.BNLearner_useScoreAIC(self)
+        noise: float, default=0.1
+                During EM's initialization, the CPTs are randomly perturbed using the following formula:
+                new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong
+                to interval [0,1]. By default, noise is equal to 0.1.
 
-    def useScoreBD(self) -> "pyagrum.BNLearner":
-        r"""
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
 
-        Indicate that we wish to use a BD score.
+        Raises
+        ------
+        pyagrum.OutOfBounds
+                if `epsilon` is strictly negative or if `noise` does not belong to interval [0,1].
 
         """
-        return _pyagrum.BNLearner_useScoreBD(self)
+        return _pyagrum.BNLearner_useEM(self, *args)
 
-    def useScoreBDeu(self) -> "pyagrum.BNLearner":
+    def useEMWithRateCriterion(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Indicate that we wish to use a BDeu score.
+        Enforces that EM with the log-likelihood min evolution rate stopping criterion will be
+        used for parameter learning when the dataset contains missing values.
 
-        """
-        return _pyagrum.BNLearner_useScoreBDeu(self)
+        Parameters
+        ----------
+        epsilon : float
+             epsilon sets the approximation stopping criterion: EM stops whenever the absolute
+             value of the relative difference between two consecutive log-likelihoods drops below
+             epsilon. Note that epsilon should be strictly positive.
 
-    def useScoreBIC(self) -> "pyagrum.BNLearner":
-        r"""
+        noise: float, default=0.1
+                During EM's initialization, the CPTs are randomly perturbed using the following formula:
+                new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong
+                to interval [0,1]. By default, noise is equal to 0.1.
 
-        Indicate that we wish to use a BIC score.
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+                if `epsilon` is not strictly positive or if `noise` does not belong to interval [0,1].
 
         """
-        return _pyagrum.BNLearner_useScoreBIC(self)
+        return _pyagrum.BNLearner_useEMWithRateCriterion(self, *args)
 
-    def useScoreK2(self) -> "pyagrum.BNLearner":
+    def useEMWithDiffCriterion(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Indicate that we wish to use a K2 score.
+        Enforces that EM with the log-likelihood min difference criterion will be used for
+        parameter learning whenever the dataset contains missing values.
+
+        Parameters
+        ----------
+        epsilon : float
+             epsilon sets the approximation stopping criterion: EM stops whenever the
+             difference between two consecutive log-likelihoods drops below
+             epsilon. Note that epsilon should be strictly positive.
+
+        noise: float (optional, default = 0.1)
+                During EM's initialization, the CPTs are randomly perturbed using the following formula:
+                new_CPT = (1-noise) * CPT + noise * random_CPT. Parameter noise must belong
+                to interval [0,1]. By default, noise is equal to 0.1.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+                if epsilon is not strictly positive or if noise does not belong to interval [0,1].
+
+        """
+        return _pyagrum.BNLearner_useEMWithDiffCriterion(self, *args)
+
+    def forbidEM(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Forbids the use of EM for parameter learning.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_forbidEM(self)
+
+    def EMsetEpsilon(self, eps: float) -> "pyagrum.BNLearner":
+        r"""
+
+        Enforces that the minimal difference between two consecutive log-likelihoods
+        is chosen as a stopping criterion of the EM parameter learning algorithm and
+        specifies the threshold on this criterion.
+
+        Parameters
+        ----------
+        eps: float
+                the log-likelihood difference below which EM stops its iterations
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+                If eps <= 0.
+
+        """
+        return _pyagrum.BNLearner_EMsetEpsilon(self, eps)
+
+    def EMdisableEpsilon(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Disables the minimal difference between two consecutive log-likelihoods as a
+        stopping criterion for the EM parameter learning algorithm.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMdisableEpsilon(self)
+
+    def EMenableEpsilon(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Enforces that the minimal difference between two consecutive log-likelihoods is
+        a stopping criterion for the EM parameter learning algorithm.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Warnings:
+        ---------
+        Setting the min difference between two consecutive log-likelihoods as a stopping
+        criterion disables the min log-likelihood evolution rate as a stopping criterion.
+
+        """
+        return _pyagrum.BNLearner_EMenableEpsilon(self)
+
+    def EMsetMinEpsilonRate(self, rate: float) -> "pyagrum.BNLearner":
+        r"""
+
+        Enforces that the minimal log-likelihood's evolution rate is considered by the EM
+        parameter learning algorithm as a stopping criterion.
+
+        Parameters
+        ----------
+        rate: float
+        	the log-likelihood evolution rate below which EM stops its iterations
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+        	If rate <= 0.
+
+        Warnings
+        --------
+        Setting this stopping criterion disables the min log-likelihod difference criterion
+        (if this one was enabled).
+
+        """
+        return _pyagrum.BNLearner_EMsetMinEpsilonRate(self, rate)
+
+    def EMdisableMinEpsilonRate(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Disables the minimal log-likelihood's evolution rate as an EM parameter learning
+        stopping criterion.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMdisableMinEpsilonRate(self)
+
+    def EMenableMinEpsilonRate(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Enables the minimal log-likelihood's evolution rate as an EM parameter learning
+        stopping criterion.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Warnings
+        --------
+        Setting this stopping criterion disables the min log-likelihod difference criterion.
+
+        """
+        return _pyagrum.BNLearner_EMenableMinEpsilonRate(self)
+
+    def EMsetMaxIter(self, max: int) -> "pyagrum.BNLearner":
+        r"""
+
+        Enforces a limit on the number of expectation/maximization steps performed by EM.
+
+        Parameters
+        ----------
+        max : int
+        	the maximal number of iterations that EM is allowed to perform
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+        	If max <= 1.
+
+        """
+        return _pyagrum.BNLearner_EMsetMaxIter(self, max)
+
+    def EMdisableMaxIter(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Do not limit EM to perform a maximal number of iterations.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMdisableMaxIter(self)
+
+    def EMenableMaxIter(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Enables a limit on the number of iterations performed by EM. This number is
+        equal to the last number specified with Method `EMsetMaxIter()`.
+        See Method `EMMaxIter()` to get its current value.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMenableMaxIter(self)
+
+    def EMsetMaxTime(self, timeout: float) -> "pyagrum.BNLearner":
+        r"""
+
+        Adds a constraint on the time that EM is allowed to run for learning
+        parameters.
+
+        Parameters
+        ----------
+        timeout : float
+        	the timeout in milliseconds
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        Raises
+        ------
+        pyagrum.OutOfBounds
+                If timeout<=0.0
+
+        """
+        return _pyagrum.BNLearner_EMsetMaxTime(self, timeout)
+
+    def EMdisableMaxTime(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Allow EM to learn parameters for an infinite amount of time.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMdisableMaxTime(self)
+
+    def EMenableMaxTime(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Forbid EM to run more than a given amount of time.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMenableMaxTime(self)
+
+    def EMsetPeriodSize(self, p: int) -> "pyagrum.BNLearner":
+        return _pyagrum.BNLearner_EMsetPeriodSize(self, p)
+
+    def EMPeriodSize(self) -> int:
+        return _pyagrum.BNLearner_EMPeriodSize(self)
+
+    def EMsetVerbosity(self, v: bool) -> "pyagrum.BNLearner":
+        r"""
+
+        Sets or unsets the verbosity of the EM parameter learning algorithm.
+
+        Verbosity is necessary for keeping track of the history of the learning.
+        See Method `EMHistory()`.
+
+        Parameters
+        ----------
+        v : bool
+        	sets EM's verbose mode if and only if v = True.
+
+        Returns
+        -------
+        pyagrum.BNLearner
+                the BNLearner itself, so that we can chain useXXX() methods.
+
+        """
+        return _pyagrum.BNLearner_EMsetVerbosity(self, v)
+
+    def useScoreAIC(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Indicate that we wish to use an AIC score.
+
+        """
+        return _pyagrum.BNLearner_useScoreAIC(self)
+
+    def useScoreBD(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Indicate that we wish to use a BD score.
+
+        """
+        return _pyagrum.BNLearner_useScoreBD(self)
+
+    def useScoreBDeu(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Indicate that we wish to use a BDeu score.
+
+        """
+        return _pyagrum.BNLearner_useScoreBDeu(self)
+
+    def useScoreBIC(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Indicate that we wish to use a BIC score.
+
+        """
+        return _pyagrum.BNLearner_useScoreBIC(self)
+
+    def useScoreK2(self) -> "pyagrum.BNLearner":
+        r"""
+
+        Indicate that we wish to use a K2 score.
 
         """
         return _pyagrum.BNLearner_useScoreK2(self)
@@ -24487,7 +25168,12 @@ class BNLearner(object):
     def addForbiddenArc(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        The arc in parameters won't be added.
+        Forbid the arc passed in argument to be added during structure learning
+        (methods `learnDAG()` or `learnBN()`).
+
+        Usage:
+          1. addForbiddenArc(tail, head)
+          2. addForbiddenArc(arc)
 
         Parameters
         ----------
@@ -24521,7 +25207,12 @@ class BNLearner(object):
     def addMandatoryArc(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Allow to add prior structural knowledge.
+        Allow an arc to be added if necessary during structure learning
+        (methods `learnDAG()` or `learnBN()`).
+
+        Usage:
+          1. addMandatoryArc(tail, head)
+          2. addMandatoryArc(arc)
 
         Parameters
         ----------
@@ -24562,8 +25253,8 @@ class BNLearner(object):
 
         Warnings
         --------
-          By default, all edge is possible. However, once at least one possible edge is defined, all other edges not declared possible
-          are considered as impossible.
+        By default, all edge is possible. However, once at least one possible edge is defined,
+        all other edges not declared possible are considered as impossible.
 
         Parameters
         ----------
@@ -24615,7 +25306,7 @@ class BNLearner(object):
         Parameters
         ----------
         node : int str
-          a variable's id or name
+        	a variable's id or name
 
         """
         return _pyagrum.BNLearner_addNoParentNode(self, *args)
@@ -24628,7 +25319,7 @@ class BNLearner(object):
         Parameters
         ----------
         node : int str
-          a variable's id or name
+        	a variable's id or name
 
         """
         return _pyagrum.BNLearner_eraseNoParentNode(self, *args)
@@ -24636,12 +25327,12 @@ class BNLearner(object):
     def addNoChildrenNode(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Add the constraint that this node cannot have any children.
+        Add to structure learning algorithms the constraint that this node cannot have any children.
 
         Parameters
         ----------
         node : int str
-          a variable's id or name
+        	a variable's id or name
 
         """
         return _pyagrum.BNLearner_addNoChildrenNode(self, *args)
@@ -24649,12 +25340,12 @@ class BNLearner(object):
     def eraseNoChildrenNode(self, *args) -> "pyagrum.BNLearner":
         r"""
 
-        Remove the constraint that this node cannot have any children.
+        Remove in structure learning algorithms the constraint that this node cannot have any children.
 
         Parameters
         ----------
         node : int str
-          a variable's id or name
+        	a variable's id or name
 
         """
         return _pyagrum.BNLearner_eraseNoChildrenNode(self, *args)
@@ -24916,17 +25607,18 @@ class BNLearner(object):
     def learnPDAG(self) -> "pyagrum.PDAG":
         r"""
 
-        learn a PDAG from a file
-
-        Warnings
-        --------
-          The learning method must be constraint-based (MIIC, etc.) and not score-based (K2, GreedyHillClimbing, etc.)
+        learn a partially directed acyclic graph (PDAG) from the BNLearner's database
 
         Returns
         -------
         pyagrum.PDAG
         	the learned PDAG
 
+        Warnings
+        --------
+          The learning method must be constraint-based (MIIC, etc.) and not score-based
+          (K2, GreedyHillClimbing, etc.)
+
         """
         return _pyagrum.BNLearner_learnPDAG(self)
 
@@ -24936,7 +25628,7 @@ class BNLearner(object):
         Returns
         -------
         Tuple[str]
-        	the names of the variables in the database
+                the names of the variables in the database
 
         """
         return _pyagrum.BNLearner_names(self)
@@ -24968,12 +25660,12 @@ class BNLearner(object):
         Parameters
         ----------
         id
-        	a node id
+                a node id
 
         Returns
         -------
         str
-        	the variable's name
+                the variable's name
 
         """
         return _pyagrum.BNLearner_nameFromId(self, id)
@@ -24991,7 +25683,7 @@ class BNLearner(object):
         Parameters
         ----------
         weight : float
-        	the database weight
+                the database weight
 
         """
         return _pyagrum.BNLearner_setDatabaseWeight(self, new_weight)
@@ -25074,15 +25766,15 @@ class BNLearner(object):
         Parameters
         ----------
         vars: List[str]
-        	the name of the columns of interest
+                the name of the columns of interest
 
         knowing : List[str]
-        	the (optional) list of names of conditioning columns
+                the (optional) list of names of conditioning columns
 
         Returns
         -------
         float
-        	the log-likelihood (base 2)
+                the log-likelihood (base 2)
 
         """
         return _pyagrum.BNLearner_logLikelihood(self, *args)
@@ -25121,13 +25813,13 @@ class BNLearner(object):
         Parameters
         ----------
         name1: str
-        	the name of the first column
+                the name of the first column
 
         name2 : str
-        	the name of the second column
+                the name of the second column
 
         knowing : List[str]
-        	the list of names of conditioning columns
+                the list of names of conditioning columns
 
         Returns
         -------
@@ -25151,18 +25843,18 @@ class BNLearner(object):
         Parameters
         ----------
         name1: str
-        	the name of the first column
+                the name of the first column
 
         name2 : str
-        	the name of the second column
+                the name of the second column
 
         knowing : List[str]
-        	the list of names of conditioning columns
+                the list of names of conditioning columns
 
         Returns
         -------
         Tuple[float,float]
-        	the G2 statistic and the associated p-value as a Tuple
+                the G2 statistic and the associated p-value as a Tuple
 
         """
         return _pyagrum.BNLearner_correctedMutualInformation(self, *args)
@@ -25176,12 +25868,12 @@ class BNLearner(object):
         Parameters
         ----------
         vars: List[intstr]
-        	the list of variables
+                the list of variables
 
         Returns
         -------
         List[float]
-        	the pseudo-count as a list of float
+                the pseudo-count as a list of float
 
         """
         return _pyagrum.BNLearner_rawPseudoCount(self, *args)
@@ -25195,7 +25887,7 @@ class BNLearner(object):
         Returns
         -------
         int
-        	the number of rows in the database
+                the number of rows in the database
 
         """
         return _pyagrum.BNLearner_nbRows(self)
@@ -25209,7 +25901,7 @@ class BNLearner(object):
         Returns
         -------
         int
-        	the number of columns in the database
+                the number of columns in the database
 
         """
         return _pyagrum.BNLearner_nbCols(self)
@@ -25227,6 +25919,157 @@ class BNLearner(object):
         """
         return _pyagrum.BNLearner_domainSize(self, *args)
 
+    def isUsingEM(self) -> bool:
+        r"""
+
+        returns a Boolean indicating whether EM is used for parameter learning when
+        the database contains missing values.
+
+        """
+        return _pyagrum.BNLearner_isUsingEM(self)
+
+    def EMEpsilon(self) -> float:
+        r"""
+
+        Returns a float corresponding to the minimal difference between two consecutive
+        log-likelihoods under which the EM parameter learning algorithm stops.
+
+        Returns
+        -------
+        float
+               the minimal difference between two consecutive log-likelihoods under which EM stops.
+
+        """
+        return _pyagrum.BNLearner_EMEpsilon(self)
+
+    def EMisEnabledEpsilon(self) -> bool:
+        r"""
+
+        Returns a Boolean indicating whether the minimal difference between two consecutive
+        log-likelihoods is a stopping criterion for the EM parameter learning algorithm.
+
+        """
+        return _pyagrum.BNLearner_EMisEnabledEpsilon(self)
+
+    def EMMinEpsilonRate(self) -> float:
+        r"""
+
+        Returns a float corresponding to the minimal log-likelihood's evolution rate under
+        which the EM parameter learning algorithm stops its iterations.
+
+        Returns
+        -------
+        float
+        	the limit under which EM stops its expectation/maximization iterations
+
+        """
+        return _pyagrum.BNLearner_EMMinEpsilonRate(self)
+
+    def EMisEnabledMinEpsilonRate(self) -> bool:
+        r"""
+
+        Returns a Boolean indicating whether the minimal log-likelihood's evolution rate is
+        considered as a stopping criterion by the EM parameter learning algorithm.
+
+        """
+        return _pyagrum.BNLearner_EMisEnabledMinEpsilonRate(self)
+
+    def EMMaxIter(self) -> int:
+        r"""
+
+        Returns an int containing the max number of iterations the EM parameter learning
+        algorithm is allowed to perform when the max iterations stopping criterion is enabled.
+
+        Returns
+        -------
+        float
+        	the max number of expectation/maximization iterations EM is allowed to perform
+
+        """
+        return _pyagrum.BNLearner_EMMaxIter(self)
+
+    def EMisEnabledMaxIter(self) -> bool:
+        r"""
+
+        Returns a Boolean indicating whether the max number of iterations is used
+        by EM as a stopping criterion.
+
+        """
+        return _pyagrum.BNLearner_EMisEnabledMaxIter(self)
+
+    def EMMaxTime(self) -> float:
+        r"""
+
+        Returns a float indicating EM's time limit when the max time stopping
+        criterion is used by the EM parameter learning algorithm.
+
+        Returns
+        -------
+        float
+                the max time EM is allowed to execute its expectation/maximization iterations
+
+        """
+        return _pyagrum.BNLearner_EMMaxTime(self)
+
+    def EMisEnabledMaxTime(self) -> bool:
+        r"""
+
+        Returns a Boolean indicating whether the max time criterion is used as
+        an EM stopping criterion.
+
+        """
+        return _pyagrum.BNLearner_EMisEnabledMaxTime(self)
+
+    def EMVerbosity(self) -> bool:
+        r"""
+
+        Returns a Boolean indicating whether the EM parameter learning algorithm
+        is in a verbose mode.
+
+        Note that EM verbosity is necessary for recording the history of the
+        log-likelihoods computed at each expectation/maximization step.
+
+        Returns
+        -------
+        bool
+                indicates whether EM's verbose mode is active or not
+
+        """
+        return _pyagrum.BNLearner_EMVerbosity(self)
+
+    def EMnbrIterations(self) -> int:
+        r"""
+
+        Returns the number of iterations performed by the EM parameter learning algorithm.
+
+        """
+        return _pyagrum.BNLearner_EMnbrIterations(self)
+
+    def EMHistory(self) -> List[float]:
+        r"""
+
+        Returns a list containing the log-likelihoods recorded after each
+        expectation/maximization iteration of the EM parameter learning algorithm.
+
+        Returns
+        -------
+        List[float]
+                A list of all the log-likelihoods recorded during EM's execution
+
+        Warnings
+        --------
+        Recording log-likelihoods is enabled only when EM is executed in verbose
+        mode. See method `EMsetVerbosity()`.
+
+        """
+        return _pyagrum.BNLearner_EMHistory(self)
+
+    def EMStateApproximationScheme(self) -> int:
+        return _pyagrum.BNLearner_EMStateApproximationScheme(self)
+
+    def EMStateMessage(self) -> str:
+        return _pyagrum.BNLearner_EMStateMessage(self)
+
     def setNumberOfThreads(self, nb: int) -> None:
         r"""
 
@@ -25270,24 +26113,31 @@ class BNLearner(object):
     def chi2(self, *args) -> object:
         r"""
 
-        chi2 computes the chi2 statistic and p-value for two columns, given a list of other columns.
+        chi2 computes the chi2 statistic and p-value of two variables conditionally to a
+        list of other variables.
 
+        The variables correspond to columns in the database and are specified as the
+        names of these columns in the database. The list of variables in the conditioning
+        set can be empty. In this case, no need to specify it.
+
+        Usage:
+          * `chi2(name1, name2, knowing=[])`
 
         Parameters
         ----------
         name1: str
-        	the name of the first column
+                the name of a variable/column in the database
 
         name2 : str
-        	the name of the second column
+                the name/column of another variable
 
         knowing : List[str]
-        	the list of names of conditioning columns
+                the list of the column names of the conditioning variables
 
         Returns
         -------
         Tuple[float,float]
-        	the chi2 statistic and the associated p-value as a Tuple
+                the chi2 statistics and the associated p-value as a Tuple
 
         """
         return _pyagrum.BNLearner_chi2(self, *args)
@@ -25295,28 +26145,38 @@ class BNLearner(object):
     def G2(self, *args) -> object:
         r"""
 
-        G2 computes the G2 statistic and p-value for two columns, given a list of other columns.
+        G2 computes the G2 statistic and p-value of two variables conditionally to a
+        list of other variables.
+
+        The variables correspond to columns in the database and are specified as the
+        names of these columns in the database. The list of variables in the conditioning
+        set can be empty. In this case, no need to specify it.
 
+        Usage:
+          * `G2(name1, name2, knowing=[])`
 
         Parameters
         ----------
         name1: str
-        	the name of the first column
+                the name of a variable/column in the database
 
         name2 : str
-        	the name of the second column
+                the name/column of another variable
 
         knowing : List[str]
-        	the list of names of conditioning columns
+                the list of the column names of the conditioning variables
 
         Returns
         -------
         Tuple[float,float]
-        	the G2 statistic and the associated p-value as a Tuple
+                the G2 statistics and the corresponding p-value as a Tuple
 
         """
         return _pyagrum.BNLearner_G2(self, *args)
 
+    def _EM_warning(self) -> bool:
+        return _pyagrum.BNLearner__EM_warning(self)
+
     def setSliceOrder(self, *args) -> "pyagrum.BNLearner":
         r"""
 
@@ -25374,7 +26234,7 @@ class BNLearner(object):
     def setPossibleEdges(self, *args) -> None:
         r"""
 
-        Add a constraint by fixing the set of possible edges.
+        Adds a constraint to the structure learning algorithm by fixing the set of possible edges.
 
         Parameters
         ----------
@@ -25409,30 +26269,12 @@ class BNLearner(object):
         return p
 
     def fitParameters(self,bn,take_into_account_score=True):
-      """
-      fitParameters directly populates the CPTs of the argument using the database and the structure of the BN.
+      if not set(self.names()).issuperset(bn.names()):
+        raise Exception(f"Some variables are in the BN but not in the data : {bn.names()-set(self.names())}")
 
-      Parameters
-      ----------
-      bn : pyagrum.BayesNet
-        a BN which will directly have its parameters learned inplace.
-
-      take_into_account_score : bool
-    	The dag passed in argument may have been learnt from a structure learning. In this case, if the score used to learn the structure has an implicit prior (like K2 which has a 1-smoothing prior), it is important to also take into account this implicit prior for parameter learning. By default (`take_into_account_score=True`), we will learn parameters by taking into account the prior specified by methods usePriorXXX () + the implicit prior of the score (if any). If `take_into_account_score=False`, we just take into account the prior specified by `usePriorXXX()`.
-
-      """
-      if set(self.names())!=bn.names():
-        raise Exception("Not the same variable names in the database and in the BN")
-
-      from pyagrum import DAG
-      d=DAG()
-      for n in bn.names():
-        d.addNodeWithId(self.idFromName(n))
-      for i1,i2 in bn.arcs():
-        d.addArc(self.idFromName(bn.variable(i1).name()),self.idFromName(bn.variable(i2).name()))
-      tmp=self.learnParameters(d,take_into_account_score)
+      tmp=self.learnParameters(bn,take_into_account_score)
       for n in tmp.names():
-        bn.cpt(n).fillWith(tmp.cpt(n))
+        bn.cpt(bn.idFromName(n)).fillWith(tmp.cpt(n))
       return self
 
     def learnEssentialGraph(self):
@@ -28707,7 +29549,7 @@ class ShaferShenoyLIMIDInference(object):
 
 # Register ShaferShenoyLIMIDInference in _pyagrum:
 _pyagrum.ShaferShenoyLIMIDInference_swigregister(ShaferShenoyLIMIDInference)
-__version__ = '2.1.1.9'
+__version__ = '2.3.1.9'
 __license__ = __doc__
 __project_url__ = 'https://agrum.org'
 __project_name__ = 'pyAgrum'
@@ -28754,8 +29596,12 @@ def about():
 #   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
 #   OTHER DEALINGS IN THE SOFTWARE.                                        #
 #                                                                          #
-#   See the GNU Lesser General Public License (LICENSE.LGPL) and the MIT   #
-#   licence (LICENSE.MIT) for more details.                                #
+#   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                                      #
@@ -30585,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.1.1.9'
+__version__ = '2.3.1.9'
 __license__ = __doc__
 __project_url__ = 'https://agrum.org'
 __project_name__ = 'pyAgrum'
@@ -30632,8 +31478,12 @@ def about():
 #   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  #
 #   OTHER DEALINGS IN THE SOFTWARE.                                        #
 #                                                                          #
-#   See the GNU Lesser General Public License (LICENSE.LGPL) and the MIT   #
-#   licence (LICENSE.MIT) for more details.                                #
+#   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                                      #