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

pyagrum/lib/discreteTypeProcessor.py

@@ -25,8 +25,12 @@
 #   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                                      #
@@ -125,7 +129,12 @@ class DiscreteTypeProcessor:
 
   """
 
-  def __init__(self, defaultDiscretizationMethod="quantile", defaultNumberOfBins=10, discretizationThreshold=25):
+  def __init__(
+    self,
+    defaultDiscretizationMethod="quantile",
+    defaultNumberOfBins=10,
+    discretizationThreshold=25,
+  ):
     """
     Initializes the DiscreteTypeProcessor object.
 
@@ -174,7 +183,7 @@ class DiscreteTypeProcessor:
       self.discretizationParametersDictionary = {}
 
   @gum.deprecated_arg(newA="parameters", oldA="paramDiscretizationMethod", version="2.0.0")
-  def setDiscretizationParameters(self, variableName=None, method=None, parameters=None):
+  def setDiscretizationParameters(self, variableName: str, method: str, parameters: Any = None):
     """
     Sets the discretization parameters for a variable. If variableName is None, sets the default parameters.
 
@@ -197,44 +206,40 @@ class DiscreteTypeProcessor:
           - 'expert': this parameter is the set of ticks proposed by the expert. The discretized variable will set the flag
           'empirical' which means that if the values found in the data are not in the proposed intervals, they did not raise
           any exception but  are nevertheless accepted (as belonging to the smallest or biggest interval).
-          - 'NoDiscretization': this parameter is a superset of the values for the variable found in the database.
+          - 'NoDiscretization': this parameter is a superset of the values for the variable found in the database (or None).
     """
-    if variableName in self.discretizationParametersDictionary:
-      oldParamDiscretizationMethod = self.discretizationParametersDictionary[variableName]["param"]
-      oldMethod = self.discretizationParametersDictionary[variableName]["method"]
-    else:
-      oldParamDiscretizationMethod = self.defaultParamDiscretizationMethod
-      oldMethod = self.defaultMethod
-
-    if method is None:
-      method = oldMethod
-
-    if parameters is None and method not in {"NoDiscretization", "expert"}:
-      parameters = oldParamDiscretizationMethod
-
-    if method not in {"kmeans", "uniform", "quantile", "NML", "MDLP", "CAIM", "NoDiscretization", "expert"}:
-      raise ValueError(
-        "This discretization method is not recognized! Possible values are kmeans, uniform, quantile, NML, "
-        "CAIM, MDLP, NoDiscretization or expert. You have entered " + str(method)
-      )
+    if parameters is None:
+      parameters = self.defaultParamDiscretizationMethod
 
-    if parameters == "elbowMethod":
-      if method == "NML":
-        raise ValueError(
-          "The elbow Method cannot be used as the number of bins for the algorithm NML. Please select an integer value"
-        )
-    elif method not in {"NoDiscretization", "expert"}:
-      try:
-        _ = int(parameters)
-      except ValueError:
-        raise ValueError(
-          "The possible values for paramDiscretizationMethod are any integer or the string 'elbowMethod'. You have entered: "
-          + str(parameters)
-        )
-    else:
-      if parameters is not None and not isinstance(parameters, list):
+    match method:
+      case "quantile" | "NML":
+        if type(parameters) is not int:
+          raise ValueError(
+            "The parameter for the quantile/NML method must be an integer. You have entered: " + str(parameters)
+          )
+      case "kmeans" | "uniform":
+        if type(parameters) is not int and str(parameters) != "elbowMethod":
+          raise ValueError(
+            "The parameter for the kmeans/uniform method must be an integer or the string 'elbowMethod'. You have entered: "
+            + str(parameters)
+          )
+      case "expert":
+        if not (isinstance(parameters, list) and all(map(check_float, parameters))):
+          raise ValueError(
+            "The parameter for the expert method must be a list of float. You have entered: " + str(parameters)
+          )
+      case "NoDiscretization":
+        if parameters is not None and not (isinstance(parameters, str)):
+          raise ValueError(
+            "The parameter for the NoDiscretization method must be a string (fastVar syntax) or None. You have "
+            "entered: " + str(parameters)
+          )
+      case "CAIM" | "MDLP":
+        pass
+      case _:
         raise ValueError(
-          f"For a NotDiscretized/expert method, the parameter has to be None or a list of values but not '{parameters}'."
+          "This discretization method is not recognized! Possible values are kmeans, uniform, quantile, NML, "
+          "CAIM, MDLP, NoDiscretization or expert. You have entered " + str(method)
         )
 
     if variableName is None:
@@ -378,7 +383,12 @@ class DiscreteTypeProcessor:
     Xsorted = X[X.argsort(axis=None)]
     binEdgeMatrix = [[]] * 14
     for k in range(2, 16):
-      discretizer = skp.KBinsDiscretizer(k, strategy=discretizationStrategy, subsample=None)
+      discretizer = skp.KBinsDiscretizer(
+        k,
+        strategy=discretizationStrategy,
+        quantile_method="averaged_inverted_cdf",
+        subsample=None,
+      )
       discretizer.fit(Xsorted)
       binEdges = discretizer.bin_edges_[0]
       centresArray = (binEdges[1:] + binEdges[:-1]) / 2
@@ -404,7 +414,8 @@ class DiscreteTypeProcessor:
     transformedCoordinates = numpy.zeros((2, 14))
     for i in range(14):
       transformedCoordinates[:, i] = numpy.matmul(
-        coordinateChangeMatrix, numpy.array([[i], [variationArray[i] - variationArray[0]]])
+        coordinateChangeMatrix,
+        numpy.array([[i], [variationArray[i] - variationArray[0]]]),
       ).reshape(2)
 
     # we search for the minimum in our newly obtained curve
@@ -414,7 +425,8 @@ class DiscreteTypeProcessor:
         minkIndex = k
     # when we have found the minimum, we apply the inverse linear transformation to recover the optimal value of k
     minimumVector = numpy.matmul(
-      numpy.linalg.inv(coordinateChangeMatrix), transformedCoordinates[:, minkIndex].reshape(2, 1)
+      numpy.linalg.inv(coordinateChangeMatrix),
+      transformedCoordinates[:, minkIndex].reshape(2, 1),
     )
 
     # we return the list of bin edges found using said optimal number of k
@@ -511,7 +523,10 @@ class DiscreteTypeProcessor:
             break
           else:
             currentValues["boundaryIndex"] = binEdgesIndex[position - 1] + 1
-          (currentValues["leftSubintervalClass0"], currentValues["leftSubintervalClass1"]) = (0, 0)
+          (
+            currentValues["leftSubintervalClass0"],
+            currentValues["leftSubintervalClass1"],
+          ) = (0, 0)
           minimalValues["classInformationEntropy"] = math.inf
           continue
 
@@ -854,52 +869,46 @@ class DiscreteTypeProcessor:
     else:  # The user has manually set the discretization parameters for this variable
       usingDefaultParameters = False
       if self.discretizationParametersDictionary[variableName]["method"] != "NoDiscretization" and not isNumeric:
-        raise ValueError("The variable " + variableName + " is not numeric and cannot be discretized!")
+        raise ValueError(f"The variable {variableName} is not numeric and cannot be discretized!")
 
     if self.discretizationParametersDictionary[variableName]["method"] == "NoDiscretization":
       is_int_var = True
-      min_v = max_v = None
 
-      possibleValuesX = None
+      varSyntax = ""
       if "param" in self.discretizationParametersDictionary[variableName]:
-        possibleValuesX = self.discretizationParametersDictionary[variableName]["param"]
-
-      if possibleValuesX is None:
-        possibleValuesX = sorted(foundValuesX)
-      else:
-        # foundValuesX must be in possibleValuesX
-        if not foundValuesX.issubset(possibleValuesX):
+        varSyntax = self.discretizationParametersDictionary[variableName]["param"]
+        if varSyntax is None:
+          varSyntax = ""
+
+      if varSyntax != "":
+        var = gum.fastVariable(variableName + varSyntax)
+        possibleValuesX = set(var.labels())
+        f = {str(x) for x in foundValuesX}
+        if not f.issubset(possibleValuesX):
           raise ValueError(
-            f"The values passed in possibleValues ({possibleValuesX}) do not match database values ({foundValuesX})"
+            f"The values passed in possibleValues ({sorted(possibleValuesX)}) do not match database values ("
+            f"{sorted(f)})"
           )
+        return var
 
-      for value in possibleValuesX:
-        if check_int(value):
-          v = int(value)
-          if min_v is None or min_v > v:
-            min_v = v
-          if max_v is None or max_v < v:
-            max_v = v
-        else:
-          is_int_var = False
-          break
-
+      possibleValuesX = sorted(foundValuesX)
+      is_int_var = all(map(check_int, possibleValuesX))
       if is_int_var:
+        possibleValuesX = [int(x) for x in possibleValuesX]
+        max_v = int(possibleValuesX[-1])  # sorted
+        min_v = int(possibleValuesX[0])
+
         if len(possibleValuesX) == max_v - min_v + 1:  # no hole in the list of int
-          var = gum.RangeVariable(variableName, variableName, min_v, max_v)
+          return gum.RangeVariable(variableName, variableName, min_v, max_v)
         else:
-          var = gum.IntegerVariable(variableName, variableName, [int(v) for v in possibleValuesX])
-      else:
-        is_float_var = True
-        for value in possibleValuesX:
-          if not check_float(value):
-            is_float_var = False
-            break
+          return gum.IntegerVariable(variableName, variableName, possibleValuesX)
 
-        if is_float_var:
-          var = gum.NumericalDiscreteVariable(variableName, variableName, [float(v) for v in possibleValuesX])
-        else:
-          var = gum.LabelizedVariable(variableName, variableName, [str(v) for v in possibleValuesX])
+      is_float_var = all(map(check_float, possibleValuesX))
+      if is_float_var:
+        possibleValuesX = [float(x) for x in possibleValuesX]
+        return gum.NumericalDiscreteVariable(variableName, variableName, possibleValuesX)
+      else:
+        return gum.LabelizedVariable(variableName, variableName, [str(v) for v in possibleValuesX])
     else:
       self.numberOfContinuous += 1
       if self.discretizationParametersDictionary[variableName]["method"] == "expert":
@@ -913,7 +922,10 @@ class DiscreteTypeProcessor:
         if possibleValuesY is None:
           possibleValuesY = numpy.unique(y)
         binEdges = self._discretizationCAIM(
-          Xtransformed.reshape(n, 1), y.reshape(n, 1), numpy.unique(Xtransformed), possibleValuesY
+          Xtransformed.reshape(n, 1),
+          y.reshape(n, 1),
+          numpy.unique(Xtransformed),
+          possibleValuesY,
         )
       elif self.discretizationParametersDictionary[variableName]["method"] == "MDLP":
         if y is None:
@@ -924,7 +936,10 @@ class DiscreteTypeProcessor:
         if possibleValuesY is None:
           possibleValuesY = numpy.unique(y)
         binEdges = self._discretizationMDLP(
-          Xtransformed.reshape(n, 1), y.reshape(n, 1), numpy.unique(Xtransformed), possibleValuesY
+          Xtransformed.reshape(n, 1),
+          y.reshape(n, 1),
+          numpy.unique(Xtransformed),
+          possibleValuesY,
         )
       elif self.discretizationParametersDictionary[variableName]["method"] == "NML":
         binEdges = self._discretizationNML(
@@ -935,12 +950,14 @@ class DiscreteTypeProcessor:
       else:
         if self.discretizationParametersDictionary[variableName]["param"] == "elbowMethod":
           binEdges = self._discretizationElbowMethodRotation(
-            self.discretizationParametersDictionary[variableName]["method"], Xtransformed.flatten()
+            self.discretizationParametersDictionary[variableName]["method"],
+            Xtransformed.flatten(),
           )
         else:
           discre = skp.KBinsDiscretizer(
             self.discretizationParametersDictionary[variableName]["param"],
             strategy=self.discretizationParametersDictionary[variableName]["method"],
+            quantile_method="averaged_inverted_cdf",
             subsample=None,
           )
           discre.fit(X.reshape(-1, 1))
@@ -1001,7 +1018,8 @@ class DiscreteTypeProcessor:
       Class1ByLargeInterval.insert(position + 1, minimalValues["rightSubintervalClass1"])
       continueDividingInterval.insert(position + 1, True)
       totalCountByLargeInterval.insert(
-        position + 1, minimalValues["rightSubintervalClass0"] + minimalValues["rightSubintervalClass1"]
+        position + 1,
+        minimalValues["rightSubintervalClass0"] + minimalValues["rightSubintervalClass1"],
       )
       shannonEntropyByLargeInterval.insert(position + 1, minimalValues["rightSubintervalShannonEntropy"])
 

pyagrum/lib/discretizer.py

@@ -25,8 +25,12 @@
 #   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                                      #

pyagrum/lib/dynamicBN.py

@@ -25,8 +25,12 @@
 #   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                                      #