def testLabelsOfVars(self): v = gum.LabelizedVariable("a", "a") self.assertEqual(v.labels(), ("0", "1")) self.assertNotEqual(v.labels(), ("1", "0")) v = gum.LabelizedVariable( "b", "b", 0).addLabel("toto").addLabel("titi").addLabel("yes") self.assertEqual(v.labels(), ("toto", "titi", "yes")) v = gum.RangeVariable("c", "c", 0, 5) self.assertEqual(v.labels(), ("0", "1", "2", "3", "4", "5")) v = gum.RangeVariable("d", "d", 3, 5) self.assertEqual(v.labels(), ("3", "4", "5")) v = gum.DiscretizedVariable( "e", "e").addTick(1).addTick(2).addTick(3).addTick(4) self.assertEqual(v.labels(), ("[1;2[", "[2;3[", "[3;4]")) v = gum.DiscretizedVariable( "e", "e").addTick(1).addTick(2).addTick(3).addTick(4) v.setEmpirical(True) self.assertEqual(v.labels(), ("(1;2[", "[2;3[", "[3;4)")) v = gum.DiscretizedVariable("f", "f", [1, 5, 2, 4]) self.assertEqual(v.labels(), ("[1;2[", "[2;4[", "[4;5]")) v = gum.DiscretizedVariable("f", "f", [1, 5, 2, 4]) v.setEmpirical(True) self.assertEqual(v.labels(), ("(1;2[", "[2;4[", "[4;5)"))
def test_basic(): v = gum.DiscretizedVariable("v", "v") for i in [0, 4, 10, 15, 30, 40]: v.addTick(i) w = gum.DiscretizedVariable("w", "w") for i in [-1, 4, 10, 30, 40]: w.addTick(i) print("\n** From OT::Distribution to gum::Potential:") unifDistribution = ot.Uniform(0, 40) pv = gum.Potential(otagrum.Utils.Discretize(unifDistribution, v)) pw = gum.Potential(otagrum.Utils.Discretize(unifDistribution, w)) print(pv) print(pw) print("\nCatching InvalidArgumentException for bad support") try: otagrum.Utils.Discretize(ot.Uniform(1, 100), w) print("Fail") except: print("OK") print("\n** Back to OT::Distribution") print(otagrum.Utils.FromMarginal(pv)) print(otagrum.Utils.FromMarginal(pw))
def _testOrderTicks(i, j, k, l, m, n): var = gum.DiscretizedVariable("var", "test var") var.addTick(i).addTick(j).addTick(k).addTick(l).addTick(m).addTick( n) self.assertEqual(var.domainSize(), 5) self.assertEqual( str(var), "var:Discretized(<[1;2[,[2;3[,[3;4[,[4;5[,[5;6]>)")
def testHashableDiscreteVariable(self): va = gum.LabelizedVariable("a", "a") vb = gum.LabelizedVariable("b", "b", ["toto", "titi", "yes"]) vc = gum.RangeVariable("c", "c", 0, 5) vd = gum.RangeVariable("d", "d", 3, 5) ve = gum.DiscretizedVariable( "e", "e").addTick(1).addTick(2).addTick(3).addTick(4) s = set([va, vb, vc] + [vc, vd, ve] + [va, ve]) self.assertEqual(len(s), 5)
def testAddDummyVariables(self): # === LabelizedVariable v = gum.LabelizedVariable("v", "v", 0) p = gum.Potential() self.assertEqual(v.domainSize(), 0) with self.assertRaises(gum.InvalidArgument): p.add(v) v.addLabel("first") self.assertEqual(v.domainSize(), 1) p.add(v) p = gum.Potential() v.addLabel("second") self.assertEqual(v.domainSize(), 2) p.add(v) # === RangeVariable v = gum.RangeVariable("v", "v", 1, 0) p = gum.Potential() self.assertEqual(v.domainSize(), 0) with self.assertRaises(gum.InvalidArgument): p.add(v) v.setMaxVal(1) self.assertEqual(v.domainSize(), 1) p.add(v) p = gum.Potential() v.setMaxVal(2) self.assertEqual(v.domainSize(), 2) p.add(v) # === DiscretizedVariable v = gum.DiscretizedVariable("v", "v") p = gum.Potential() self.assertEqual(v.domainSize(), 0) with self.assertRaises(gum.InvalidArgument): p.add(v) v.addTick(1) self.assertEqual(v.domainSize(), 0) with self.assertRaises(gum.InvalidArgument): p.add(v) v.addTick(2) self.assertEqual(v.domainSize(), 1) p.add(v) p = gum.Potential() v.addTick(3) self.assertEqual(v.domainSize(), 2) p.add(v)
def testAddTicks(self): v = gum.DiscretizedVariable('a', '').addTick(0.5).addTick(5.9).addTick( 5.99).addTick(0.1).addTick(0.23).addTick(12) self.assertEqual(v.varType(), gum.VarType_Discretized) var = gum.DiscretizedVariable("var", "test var") self.assertTrue(var.empty()) self.assertEqual(var.domainSize(), 0) var.addTick(0.2) self.assertTrue(var.empty()) self.assertEqual(var.domainSize(), 0) var.addTick(3) self.assertTrue(var.empty()) self.assertEqual(var.domainSize(), 1) var.addTick(2) self.assertFalse(var.empty()) self.assertEqual(var.domainSize(), 2) self.assertRaises(gum.DefaultInLabel, var.addTick, 2) self.assertEqual(str(var), "var:Discretized(<[0.2;2[,[2;3]>)")
def test_fromPotential(): x = gum.DiscretizedVariable("x", "x", [0, 0.5, 1, 3.5, 10]) y = gum.LabelizedVariable("y", "y", ["chaud", "tiede", "froid"]) print(x) print(y) sys.stdout.flush() p = gum.Potential().add(x).add(y) p.fillWith([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).normalize() print(p) sys.stdout.flush() distrib = otagrum.Utils.FromPotential(p) print(distrib) print(p.margSumIn(["y"])) print(distrib.getMarginal(1))
def testNormalLimits(self): var = gum.DiscretizedVariable("var", "test var") var.addTick(2.1).addTick(2.5).addTick(2.3).addTick(2.7) self.assertEqual(str(var), "var:Discretized(<[2.1;2.3[,[2.3;2.5[,[2.5;2.7]>)") with self.assertRaises(gum.OutOfBounds): x = var.index("0") self.assertEqual(var.index("2.1"), 0) self.assertEqual(var.index("2.2"), 0) self.assertEqual(var.index("2.3"), 1) self.assertEqual(var.index("2.4"), 1) self.assertEqual(var.index("2.5"), 2) self.assertEqual(var.index("2.6"), 2) self.assertEqual(var.index("2.7"), 2) with self.assertRaises(gum.OutOfBounds): x = var.index("8")
def testReadAfterWrite(self): bn = gum.BayesNet() bn.add(gum.RangeVariable("1", "", 0, 1)) bn.add( gum.DiscretizedVariable("2", "").addTick(0.0).addTick(0.5).addTick(1.0)) bn.add(gum.LabelizedVariable("3", "", 2)) bn.add(gum.LabelizedVariable("4", "", 2)) bn.add(gum.LabelizedVariable("5", "", 3)) bn.addArc("1", "3") bn.addArc("1", "4") bn.addArc("3", "5") bn.addArc("4", "5") bn.addArc("2", "4") bn.addArc("2", "5") bn.cpt("1").fillWith([0.2, 0.8]) bn.cpt("2").fillWith([0.3, 0.7]) bn.cpt("3").fillWith([0.1, 0.9, 0.9, 0.1]) bn.cpt("4").fillWith([0.4, 0.6, 0.5, 0.5, 0.5, 0.5, 1.0, 0.0]) bn.cpt("5").fillWith([ 0.3, 0.6, 0.1, 0.5, 0.5, 0.0, 0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 0.4, 0.6, 0.0, 0.5, 0.5, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0 ]) gum.saveBN(bn, self.agrumSrcDir("o3prm/BNO3PRMIO_file.o3prm")) bn2 = gum.loadBN(self.agrumSrcDir("o3prm/BNO3PRMIO_file.o3prm"), system="bayesnet") self.assertEqual(bn.dim(), bn2.dim()) self.assertEqual(bn.log10DomainSize(), bn2.log10DomainSize()) for n in bn.names(): self.assertEqual(bn.variable(n).name(), bn2.variable(n).name()) self.assertEqual( bn.variable(n).varType(), bn2.variable(n).varType()) self.assertEqual( bn.variable(n).domainSize(), bn2.variable(n).domainSize())
def testFastBuilders(self): bn1 = gum.BayesNet() bn1.add(gum.RangeVariable("A", "A", 0, 2)) bn1.add(gum.LabelizedVariable("B", "B", ["a", "b", "c"])) bn1.add(gum.RangeVariable("C", "C", 4, 7)) bn1.add(gum.IntegerVariable("D", "D", [1, 3, 10])) bn1.add(gum.DiscretizedVariable("E", "E", [1, 1.5, 3, 3.14, 15])) bn1.addArc("A", "B") bn1.addArc("B", "C") bn1.addArc("C", "D") bn1.addArc("D", "E") self.assertEquals(len(bn1.check()), 5) # every cpt is faulty bn2 = gum.fastBN("A->B{a|b|c}->C[4,7]->D{1|3|10}->E[1,1.5,3,3.14,15]", 3) self.assertEquals(len(bn2.check()), 0) # but random bn3 = gum.BayesNet() bn3.add("A", 3) bn3.add("B{a|b|c}") bn3.add("C[4,7]") bn3.add("D{1|3|10}") bn3.add("E[1,1.5,3,3.14,15]") bn3.addArc("A", "B") bn3.addArc("B", "C") bn3.addArc("C", "D") bn3.addArc("D", "E") self.assertEquals(len(bn3.check()), 5) # every cpt is faulty bn4 = gum.BayesNet() bn4.addVariables( ["A", "B{a|b|c}", "C[4,7]", "D{1|3|10}", "E[1,1.5,3,3.14,15]"], 3) bn4.addArcs([("A", "B"), ("B", "C"), ("C", "D"), ("D", "E")]) self.assertEquals(len(bn4.check()), 5) # every cpt is faulty for name in "ABCDE": self.assertEquals(bn1.variable(name), bn2.variable(name)) self.assertEquals(bn1.variable(name), bn3.variable(name)) self.assertEquals(bn1.variable(name), bn4.variable(name))
def testLoopIn(self): u = gum.LabelizedVariable("u", "u", 4) v = gum.RangeVariable("v", "v", 1, 5) w = gum.DiscretizedVariable("w", "w", [-2, -0.5, 1, 2.5]) p = gum.Potential().fillWith(0) s = 0 for i in p.loopIn(): s += p.get(i) self.assertEqual(s, 0) p = gum.Potential().fillWith(42) s = 0 for i in p.loopIn(): s += p.get(i) self.assertEqual(s, 42) p.add(u).add(v).add(w) for i in p.loopIn(): p.set(i, random.choice([1, 2, 3])) s = 0 for i in p.loopIn(): s += p.get(i) self.assertEqual(s, p.sum())
] angle_ticks = [(n_ticks - i) * Angle.getRange().getLowerBound()[0] / (n_ticks + 1) + (i + 1.0) * Angle.getRange().getUpperBound()[0] / (n_ticks + 1) for i in range(n_ticks)] joint_ticks = [(n_ticks - i) * Joint.getRange().getLowerBound()[0] / (n_ticks + 1) + (i + 1.0) * Joint.getRange().getUpperBound()[0] / (n_ticks + 1) for i in range(n_ticks)] vibration_ticks = [-1.0, -0.5, 0.0, 0.5, 1.0] bn = gum.BayesNet() bn.add(gum.DiscretizedVariable("T", "Torque", completeTicks(Torque.getRange(),torque_ticks))) bn.add(gum.DiscretizedVariable("A", "Angle", completeTicks(Angle.getRange(),angle_ticks))) bn.add(gum.DiscretizedVariable("J", "Joint", completeTicks(Joint.getRange(),joint_ticks))) bn.add( gum.DiscretizedVariable("V", "Vibration", completeTicks(None,vibration_ticks))) bn.add(gum.LabelizedVariable("L", "Leak", ["False", "True"])) bn.addArc("T", "V") bn.addArc("T", "A") bn.addArc("J", "V") bn.addArc("J", "L") bn.addArc("A", "L") bn
#!/usr/bin/env python from __future__ import print_function import openturns as ot import otagrum import pyAgrum as gum import sys # Create variables light = gum.LabelizedVariable("Light", "quality of light", 0) moisture = gum.LabelizedVariable("Moisture", "quantity of moisture", 0) height = gum.DiscretizedVariable("Height", "plant growth") ## Create labels and ticks # light has 2 attributes : Dim and Bright light.addLabel("Dim") light.addLabel("Bright") # moisture has 2 attributes : Dry and Wet moisture.addLabel("Dry") moisture.addLabel("Wet") # height is a discretized variable [height.addTick(i) for i in range(0, 150, 10)] height.domainSize() # height has a conditional probability table # We give here its conditional distributions # We use some OT distributions
def createVariable(self, variableName, X, y=None, possibleValuesY=None): """ parameters: variableName: the name of the created variable X: ndarray shape(n,1) A column vector containing n samples of a feature. The column for which the variable will be created y: ndarray shape(n,1) A column vector containing the corresponding for each element in X. possibleValuesX: onedimensional ndarray An ndarray containing all the unique values of X possibleValuesY: onedimensional ndarray An ndarray containing all the unique values of y returnModifiedX: bool X could be modified by this function during returns: var: pyagrum.DiscreteVariable the created variable Creates a variable for the column passed in as a parameter and places it in the Bayesian network """ if y is not None: X, y = sklearn.utils.check_X_y(X, y, dtype=None, accept_sparse=True, ensure_2d=False) X = sklearn.utils.check_array(X, dtype=None, ensure_2d=False) try: Xtransformed = sklearn.utils.check_array(X, dtype='float', ensure_2d=False) isNumeric = True except ValueError: Xtransformed = X isNumeric = False possibleValuesX = numpy.unique(X) n = len(X) if variableName not in self.discretizationParametersDictionary.keys(): # The user has not manually set the discretization parameters for this variable if isNumeric and \ ((self.discretizationThreshold >= 1 and len(possibleValuesX) > self.discretizationThreshold) or (self.discretizationThreshold < 1 and len(possibleValuesX) / len(X) > self.discretizationThreshold)): self.discretizationParametersDictionary[variableName] = dict() self.discretizationParametersDictionary[variableName]['methode'] = self.defaultMethod self.discretizationParametersDictionary[variableName]['k'] = self.defaultNbBins else: self.discretizationParametersDictionary[variableName] = dict() self.discretizationParametersDictionary[variableName]['methode'] = "NoDiscretization" usingDefaultParameters = True else: usingDefaultParameters = False if self.discretizationParametersDictionary[variableName]['methode'] != "NoDiscretization" and not isNumeric: raise ValueError("The variable " + variableName + " is not numeric and cannot be discretized!") if self.discretizationParametersDictionary[variableName]["methode"] == "NoDiscretization": is_int_var=True min_v=max_v=None for value in possibleValuesX: if not checkInt(value): is_int_var=False break else: 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 if is_int_var: if len(possibleValuesX)==max_v-min_v+1: # no hole in the list of int var =gum.RangeVariable(variableName, variableName, min_v,max_v) else: var=gum.IntegerVariable(variableName, variableName,[int(v) for v in possibleValuesX]) else: var = gum.LabelizedVariable(variableName, variableName, [str(v) for v in possibleValuesX]) else: self.numberOfContinous += 1 if self.discretizationParametersDictionary[variableName]['methode'] == "CAIM": if y is None: raise ValueError( "The CAIM discretization method requires a list of the associated classes for each data vector since it " "is a supervised discretization method. You should pass it as y.") if possibleValuesY is None: possibleValuesY = numpy.unique(y) binEdges = self.discretizationCAIM(Xtransformed.reshape(n, 1), y.reshape(n, 1), numpy.unique(Xtransformed), possibleValuesY) elif self.discretizationParametersDictionary[variableName]['methode'] == "MDLP": if y is None: raise ValueError( "The MDLP discretization method requires a list of the associated classes for each data vector since it " "is a supervised discretization method. You should pass it as y.") if possibleValuesY is None: possibleValuesY = numpy.unique(y) binEdges = self.discretizationMDLP(Xtransformed.reshape(n, 1), y.reshape(n, 1), numpy.unique(Xtransformed), possibleValuesY) elif self.discretizationParametersDictionary[variableName]['methode'] == "NML": binEdges = self.discretizationNML(Xtransformed.flatten(), numpy.unique(Xtransformed), kMax=self.discretizationParametersDictionary[variableName]["k"]) else: if self.discretizationParametersDictionary[variableName]['k'] == 'elbowMethod': binEdges = self.discretizationElbowMethodRotation( self.discretizationParametersDictionary[variableName]['methode'], Xtransformed.flatten()) else: discre = skp.KBinsDiscretizer(self.discretizationParametersDictionary[variableName]['k'], strategy=self.discretizationParametersDictionary[variableName]['methode']) discre.fit(X.reshape(-1, 1)) binEdges = discre.bin_edges_[0].tolist() if len(binEdges) == 2: raise ValueError("Due to an error the discretization method " + str( self.discretizationParametersDictionary[variableName]['methode']) + " using " + str( self.discretizationParametersDictionary[variableName]['k']) + " bins for the variable " + str( variableName) + "gave only 1 bin. Try increasing the number of bins used by this variable using " "setDiscetizationParameters to avoid this error") #we replace infinity as min and max by the new empirical flag. #binEdges[0] = -math.inf #binEdges[-1] = math.inf self.totalNumberOfBins += len(binEdges) - 1 var = gum.DiscretizedVariable(variableName, variableName, binEdges) var.setEmpirical(True) if usingDefaultParameters: self.discretizationParametersDictionary.pop(variableName) return var
def setUp(self): self.bn = gum.BayesNet() self.c, self.r = \ [self.bn.add(gum.LabelizedVariable(name, name, 2)) for name in 'c r'.split()] self.s, self.w = \ [self.bn.add(gum.LabelizedVariable(name, name, 0).addLabel('no') \ .addLabel('yes')) for name in 's w'.split()] for link in [(self.c, self.s), (self.c, self.r), (self.s, self.w), (self.r, self.w)]: self.bn.addArc(*link) self.bn.cpt(self.c)[:] = [0.5, 0.5] self.bn.cpt(self.s)[:] = [[0.5, 0.5], [0.9, 0.1]] self.bn.cpt(self.r)[:] = [[0.8, 0.2], [0.2, 0.8]] self.bn.cpt(self.w)[0, 0, :] = [1, 0] self.bn.cpt(self.w)[0, 1, :] = [0.1, 0.9] self.bn.cpt(self.w)[1, 0, :] = [0.1, 0.9] self.bn.cpt(self.w)[1, 1, :] = [0.01, 0.99] self.bni = gum.BayesNet() self.ci, self.si = \ [self.bni.add(gum.LabelizedVariable(name, name, 2)) for name in 'ci si'.split()] self.ri = self.bni.add(gum.RangeVariable('ri', '', 5, 6)) vwi = gum.DiscretizedVariable('wi', '') vwi.addTick(0.2).addTick(0.4).addTick(0.6) self.wi = self.bni.add(vwi) for link in [(self.ci, self.si), (self.ci, self.ri), (self.si, self.wi), (self.ri, self.wi)]: self.bni.addArc(*link) self.bni.cpt(self.ci)[:] = [0.5, 0.5] self.bni.cpt(self.si)[:] = [[0.5, 0.5], [0.9, 0.1]] self.bni.cpt(self.ri)[:] = [[0.8, 0.2], [0.2, 0.8]] self.bni.cpt(self.wi)[0, 0, :] = [1, 0] self.bni.cpt(self.wi)[0, 1, :] = [0.1, 0.9] self.bni.cpt(self.wi)[1, 0, :] = [0.1, 0.9] self.bni.cpt(self.wi)[1, 1, :] = [0.01, 0.99] self.bn2 = gum.BayesNet() self.s2, self.r2, self.w2 = \ [self.bn2.add(gum.LabelizedVariable(name, name, 2)) for name in 's2 r2 w2'.split()] for link in [(self.r2, self.s2), (self.s2, self.w2), (self.r2, self.w2)]: self.bn2.addArc(*link) self.bn2.cpt(self.s2)[:] = [[0.6, 0.4], [0.99, 0.01]] self.bn2.cpt(self.r2)[:] = [0.8, 0.2] self.bn2.cpt(self.w2)[0, 0, :] = [1, 0] self.bn2.cpt(self.w2)[0, 1, :] = [0.1, 0.9] self.bn2.cpt(self.w2)[1, 0, :] = [0.2, 0.8] self.bn2.cpt(self.w2)[1, 1, :] = [0.01, 0.99]