def runTest(self):
# construct factors of various sizes with no data
for sz in xrange(6):
vars = ['V'+str(i) for i in xrange(sz)]
vals = dict([(v,[0,1]) for v in vars])
data = (vars,vals,vars,[])
for v_on in subsetn(vars, sz):
inst = []
for v in vars:
if v in v_on:
inst.append(1)
else:
inst.append(0)
data[3].append(tuple(inst+[0]))
d = CompactFactor(data,domain=Domain())
x2 = X2Separator(d)
g2 = G2Separator(d)
for a,b in pairs(vars):
for s in powerset(set(vars) - set([a,b])):
x2p, x2s, x2d = x2.test_independ(a, b, set(s))
g2p, g2s, g2d = g2.test_independ(a, b, set(s))
# one degree of freedom
self.assertEquals(x2d, 0)
self.assertEquals(g2d, 0)
# default to independent
self.assertEquals(x2p, 1)
self.assertEquals(g2p, 1)
# zero statistics (no data)
self.assertEquals(x2s, 0)
self.assertEquals(g2s, 0)
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 tryModel(self, model):
# perform every interventional query
ci = {}
for xs in powerset(model.variables()):
# build the intervention q
q = {}
for x in xs:
q[x] = frozenset([set(model.values(x)).pop()])
# generate the model
model_do = CBN.from_bn(model.copy(copy_domain=True))
model_do.intervene(q)
ci[frozenset(q.keys())] = GraphCI(model_do.adg())
iic = InterventionalICPattern(ci)
self.assertEquals(iic.lines(), [])
self.assertEquals(iic.orient(), model.adg())
def tryModel(self, model):
# perform every interventional query
ci = {}
for xs in powerset(model.variables()):
# build the intervention q
q = {}
for x in xs:
q[x] = frozenset([set(model.values(x)).pop()])
# generate the model
model_do = CBN.from_bn(model.copy(copy_domain=True))
model_do.intervene(q)
ci[frozenset(q.keys())] = GraphCI(model_do.adg())
iic = InterventionalICPattern(ci)
self.assertEquals(iic.lines(), [])
self.assertEquals(iic.orient(), model.adg())
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 _add_undirected_independencies(self):
# global markov property:
# a _|_ b | s
# if s separates a and b
for va, vb in pairs(self._graph.vertices()):
if self._graph.is_neighbour(va,vb):
continue
a = frozenset([va])
b = frozenset([vb])
for cond in powerset(self._graph.vertices() - (a|b)):
cond = set(cond)
if self.has_independence(va, vb):
skip = False
for pc in self._ind[self._index(va,vb)]:
if pc <= cond:
skip = True
break
if skip:
continue
if self._graph.separates(a,b,cond):
self._add_independence(va,vb,cond)
def _add_directed_independencies(self):
# directed global markov property:
# a _|_ b | s
# where s separates a and b in the moralised graph of
# the smallest ancestral set of {a,b,s}
for va,vb in pairs(self._graph.vertices()):
if self._graph.is_parent(va,vb) or self._graph.is_parent(vb,va):
continue
a = frozenset([va])
b = frozenset([vb])
for cond in powerset(self._graph.vertices() - (a|b)):
cond = frozenset(cond)
if self.has_independence(va, vb):
skip = False
for pc in self._ind[self._index(va,vb)]:
if pc <= cond:
skip = True
break
if skip:
continue
g = self._graph.ancestral_adg(a | b | cond).moralise()
if g.separates(a,b,cond):
self._add_independence(va,vb,cond)
