def runTest(self):
data = self._world.observe(num_samples)
p = CBN.from_bn(self._skel.copy(copy_domain=True))
print 'learning from',data.size(),'samples: BDeu score:',p.bdeu_score(data)
p.estimate_parameters(data)
self.failUnless(same_factor(distribution_of(p), distribution_of(self._skel), dp=2, verbose=True))
def runTest(self):
samples = GibbsSampler(self._minibn_do).samples(100000)
data = CompactFactor(samples,domain=Domain())
p = self._minibn_do.copy(copy_domain=True)
p.estimate_parameters(data)
self.failUnless(same_factor(distribution_of(p), distribution_of(self._minibn_do), dp=2, verbose=True))
def tryModel(self, model):
for var in model.variables():
# intervene at each variable in turn
model_do = CBN.from_bn(model.copy(copy_domain=True))
# check that the hyperedges correspond to all factors
self.assertEquals(frozenset([v for v,x in model_do.items()]),
frozenset(model_do._hypergraph.hyperedges()))
val = frozenset([set(model.values(var)).pop()])
model_do.intervene({var: val})
self.assertEquals(len(model_do.parents(var)), 0)
self.assertEquals(model_do.values(var), val)
self.assertEquals(len(model_do[var].data()), 1)
self.assertEquals(frozenset([v for v,x in model_do.items()]),
frozenset(model_do._hypergraph.hyperedges()))
self.assert_(model_do[var].data()[0] > 0)
for other_var in model.variables():
if other_var == var:
continue
self.assertEquals(model_do.parents(other_var), model.parents(other_var))
if var in model.parents(other_var):
self.assertEquals(frozenset(model_do[other_var].variables()), frozenset(model[other_var].variables()))
for inst in model_do[other_var].insts():
self.assertAlmostEquals(model_do[other_var][inst], model[other_var][inst])
else:
self.assert_(same_factor(model_do[other_var], model[other_var]))
def tryModel(self, orig):
orig = orig.copy(copy_domain=True)
for factor in orig:
f = factor.copy(copy_domain=True)
extension = dict([(v,f.values(v)) for v in f.variables()])
f.data_extend(extension)
self.assert_(same_factor(f,factor))
def runTest(self):
num_vars = 5
num_vals = 10
for x in xrange(num_runs):
vs = dict([('V'+str(i),range(num_vals)) for i in xrange(num_vars)])
# should get some random data with 0.
f = Factor(variables = vs.keys()
,data = [abs(randint(0,20)) for i in xrange(num_vals**num_vars)]
#,data = [5, 0, 1, 2]
#,data = [13,0,0,20]
#,data = [14,15,20,16]
,domain = Domain()
,new_domain_variables=vs
,check = True)
records = []
for inst in f.insts():
records.append(inst + (f[inst],))
rawdata = (vs.keys(), vs, vs.keys(), records)
#print records
cf = IncrementalCompactFactor(rawdata, rmin=0)
#print 'old tree:'
#print cf
# g = Factor(variables = vs.keys()
# #,data = [13,2,0,0]
# ,data = [14,15,0,0]
# ,domain = Domain()
# ,new_domain_variables=vs
# ,check = True)
g = f.copy(copy_domain=True)
def swap_some(x):
r = random()
if x == 0:
if r <= 0.5:
return randint(1,5)
return 0
elif r <= 0.5:
return 0
return x
def invert_some(x):
return 5-x
g.map(swap_some)
#print g
f += g
records = []
for inst in g.insts():
records.append(inst + (g[inst],))
rawdata = (vs.keys(), vs, vs.keys(), records)
cf.update(rawdata)
#print 'new tree:'
#print cf
for variables in powerset(vs.keys()):
g = f.copy(copy_domain=True)
g.marginalise_away(g.variables() - frozenset(variables))
self.assert_(same_factor(g,cf.makeFactor(variables),verbose=True))
def runTest(self):
num_vars = 5
num_vals = 10
for i in xrange(num_runs):
vs = dict([('V'+str(i),range(num_vals)) for i in xrange(num_vars)])
# should get some random data with 0.
f = Factor(variables = vs.keys()
,data = [abs(randint(0,5)) for i in xrange(num_vals**num_vars)]
,domain = Domain()
,new_domain_variables=vs
,check = True)
records = []
for inst in f.insts():
records.append(inst + (f[inst],))
rawdata = (vs.keys(), vs, vs.keys(), records)
cf = IncrementalCompactFactor(rawdata)
for variables in powerset(vs.keys()):
g = f.copy(copy_domain=True)
g.marginalise_away(g.variables() - frozenset(variables))
self.assert_(same_factor(g,cf.makeFactor(variables),verbose=True))
def tryModel(self, model):
# generate some samples
cf = []
sampler = ForwardSampler(model)
samples = sampler.samples(100)
cf.append(CompactFactor(samples,domain=Domain()))
icf = IncrementalCompactFactor(samples, domain=Domain())
for i in xrange(10):
samples = sampler.samples(100)
cf.append(CompactFactor(samples,domain=Domain()))
icf.update(samples)
# see if the sum of the CPT Factors in cf match that of icf
for child in model.variables():
family = model.adg().parents(child) | set([child])
a = icf.makeFactor(family)
b = cf[0].makeFactor(family)
for f in cf[1:]:
b += f.makeFactor(family)
self.assert_(same_factor(a,b))
def tryModel(self, orig):
orig = orig.copy(copy_domain=True)
for child in orig.variables():
model = orig.copy(copy_domain=True)
vals = model.values(child)
this_one = random.choice(tuple(vals))
model.condition({child: frozenset([this_one])}, keep_class=True)
for f in model:
if child not in f.variables():
self.assert_(same_factor(f, orig[f.child()]))
continue
f = f.copy(copy_domain=True)
f.data_extend({child: vals}, keep_class=True)
f.change_domain_variable(child, vals)
self.assertEquals(f.variables(), orig[f.child()].variables())
for variable in f.variables():
self.assertEquals(f.values(variable),orig[f.child()].values(variable))
i = sorted(f.variables()).index(child)
for inst in f.insts():
if inst[i] == this_one:
self.assertEquals(f[inst], orig[f.child()][inst])
else:
self.assertEquals(f[inst], 0)
def runTest(self):
data = self._world.query(self._intervention, num_samples)
p = self._query.copy(copy_domain=True)
print 'learning from',data.size(),'samples: BDeu score:',p.bdeu_score(data)
p.estimate_parameters(data)
self.failUnless(same_factor(distribution_of(p), distribution_of(self._query), dp=2, verbose=True))
