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]
