t = line[:-1].split(delim)
nof_cols = len(t)
if not nof_cols0: nof_cols0 = nof_cols
if nof_cols != nof_cols0:
return False, 0, 0, msg(lineno, nof_cols0, nof_cols, t)
return True, lineno + 1 - nof_empty, nof_cols0, ""
# And if so (and even if not) makes the result tab limited
def main(infn, delim=None, keep_empty=False):
if delim == '\\t': delim = '\t'
ok, nof_rows, nof_cols, msg = formatcheck(infn, delim, keep_empty)
print int(ok)
print ok and ("%d %d" % (nof_rows, nof_cols)) or msg
if __name__ == "__main__":
from coliche import che
che(
main, """datafile
-d --delim delim : field separator (default whitespaces)
-k --keep-empty (bool) : don't skip empty lines
""")
import propreg
import sys
def main(N, H0):
mlines = ("I %s %s" % (H0, H0),
"O %s %s" % (H0, H0))
h0 = float(H0)
for f1 in xrange(N+1):
p = float(f1)/N
f0 = N-f1
p0, p1 = propreg.proptest((f0, f1), mlines)
print p, p0
if __name__ == '__main__':
from coliche import che
che(main,
""" N (int); H0;
""")
if __name__ == '__main__':
import coliche
import bnsearch
import constraints
def main(bdtfile,
scoretype='BDeu',
ess=1.0,
outfile=None,
constraint_file="",
cachefile=None):
bn, sc = bnsearch.empty_net(bdtfile,
scoretype,
ess,
cachefile=cachefile)
cstrs = constraints.Constraints(constraint_file)
kruskal(bn, sc, cstrs)
if outfile:
bn.save(outfile)
sc.score_new(bn)
print sc.score()
coliche.che(
main, ''' bdtfile;
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-c constraint_file : a file with arcs marked with (+) or -
-o outfile : file to save the model found
-m --cachefile cachefile: local scores
''')
bn.delarc(a)
#print 'ADEL', bn.arcs()
#for v in bn.vars(): print v, bn.path_in_counts[v]
sc.score_new(bn)
if (iters and t > iters): break
if 'SIGUSR2' in sigpool.flags: break
if 'SIGUSR1' in sigpool.flags:
if outfile: good_nets[-1][1].save(outfile)
print good_nets[-1][0]
sigpool.flags.remove('SIGUSR1')
if outfile:
good_nets[-1][1].save(outfile)
print good_nets[-1][0]
coliche.che(
main, ''' bdtfile;
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-t time : like -t '4d 3h 5m 5[s]' (default till SIGUSR2)
-i --iters iters (int) :number of iterations (default infinite)
-c constraint_file : a file with arcs marked with + or -
-o outfile : file to save the model found
-s --start startbn : file to start search from
-m --cachefile cachefile: local scores
''')
#!/usr/bin/env python
from bn.bn import load as load_bn
from bn.learn.constraints import Constraints
import coliche
from itertools import combinations
def gen_forbidden_arcs(bn):
sarcs = frozenset(tuple(arc) for arc in map(sorted, bn.arcs()))
for arc in combinations(bn.vars(), 2):
if not arc in sarcs:
yield arc
yield tuple(reversed(arc))
def main(bnfile, cstrfile):
bn = load_bn(bnfile)
cstrs = Constraints()
for arc in gen_forbidden_arcs(bn):
cstrs.no.add(arc)
cstrs.save(cstrfile)
if __name__ == '__main__':
coliche.che(main, 'bnfile; cstrfile')
l = f.readline()
self.thetas = thetas
f.close()
return self
def bnt(bnm): # strangely needed for inout
return bnm.bn
# maybe learning should be put to another file
def main(vdfile, bnfile, datfile, outfile, ess=1.0, type="bdeu"):
valcs = bn.vd.load(vdfile)
bns = bn.bn.load(bnfile, do_pic=False)
dat = disdat.RowData(vdfile, datfile)
bnm = BnModel(bns, valcs)
bnm.init_param_learning(valcs.vcs, type.lower(), ess)
bnm.learn_params(dat)
bnm.save(valcs.varnames, outfile)
if __name__ == '__main__':
from coliche import che
che(
main, ''' vdfile; bnfile; datfile; outfile
-t --type type bdeu|cnml|dir|ml|bds|bdq : bdeu, bds, bdq, ml, cnml or dir: default bdeu
-e --ess ess (float) : a parameter if needed: default 1.0
''')
print('Unknown inferer type:', irtype)
return
while True:
l = raw_input().strip()
if not l: continue
if l.startswith("q"): break
argv = l.split()
c = argv.pop(0)
if c == 'e':
r = ir.evidence(argv)
elif c == 'w':
r = ir.watch(argv)
elif c == 'r':
r = ir.reset()
elif c == 'i':
r = ir.infer()
else:
r = ir.nocmd()
if r: print "ERROR:", r
coliche.che(
main, """irtype
--ifrdir ifrdir : if irtype is jt
-f --fmt vdfile : needed but for jt
--bnmodel bnmfile : if irtype is gibbs or bucketelim or lhweighting
""")
bn = load(bnfile)
stages = []
varsleft = set(bn.vars())
while len(varsleft) > 0:
sources = set(v for v in varsleft if len(bn.parents(v)) == 0)
stages.append(sources)
varsleft -= sources
for v in sources:
for c in bn.children(v):
bn.delarc((v, c))
return stages
def fac(n):
r = 1
for x in xrange(1, n + 1):
r *= x
return r
import coliche
stages = coliche.che(main, 'bnfile')
print 'THIS DOES NOT WORK'
print stages
if stages != None:
res = 1
for s in stages:
res *= fac(len(s))
print res
# print "Rs[n-r]",Rs[n-r]
yield bnt * Rs[r]
return sum(rts())
def Rs(N,K):
l = list(xlogs(N+1))
lf = list(xlogfacs(l))
Rs = [1]*(N+1)
yield Rs
for k in xrange(2,K+1):
Rs = [R(k,n,Rs,l,lf) for n in xrange(N+1)]
yield Rs
if __name__ == '__main__':
import coliche
def main(N,K,filename):
f = open(filename,"w")
for rk in Rs(N,K):
#print >>f, " ".join(["%8.2f" % r for r in rk])
print >>f, " ".join(map(str, rk))
f.close()
coliche.che(main, "N (int); K (int); filename")
'task_index' : '--task-index %d' % task_index,
'cstr' : '-c %s' % cstrfile if cstrfile != None else '',
'ext' : '.exe' if sys.platform == 'win32' else ''
}
scorecmd = """
{binpath/}get_local_scores{ext} {vdfile} {datfile} {score} {rdir/}res {nof_tasks} {task_index} {cstr}
{binpath/}split_local_scores{ext} {nof_vars} {rdir}
{binpath/}reverse_local_scores{ext} {nof_vars} {rdir}
{binpath/}get_best_parents{ext} {nof_vars} {rdir}
{binpath/}get_best_sinks{ext} {nof_vars} {rdir} {rdir/}sinks
{binpath/}get_best_order{ext} {nof_vars} {rdir}/sinks {rdir/}ord
{binpath/}get_best_net{ext} {nof_vars} {rdir} {rdir/}ord {rdir/}net
{binpath/}score_net{ext} {rdir/}net {rdir}
""".format(**kws)
if os.path.exists(resdir):
if not os.path.isdir(resdir):
sys.exit('%s is not a directory' % resir)
else:
os.makedirs(resdir)
subprocess.call(scorecmd, shell=True)
from coliche import che
che(main,
"""vdfile;datfile;score;resdir;
--nof-tasks nof_tasks(int): default: 1
--task-index task_index: default: 0
-c --constraints cstrfile
""")
topN=0,
dump_worklist=False):
cstrs = Constraints(constraint_file)
bn0 = bnmodule.load(bnfile)
sc = scorefactory.getscorer(data.Data(bdtfile),
scoretype,
ess,
cachefile=cachefile)
c = 0
for (_bnas, s) in hpcrawl([bn0],
sc,
cstrs=cstrs,
topN=topN,
dump_worklist=dump_worklist):
print c, s
# if c == 20000:
# bnmodule.BN(bn0.varc,_bnas,do_pic=False).save('X%d.bn' % c)
c += 1
coliche.che(
main, """bnfile; bdtfile;
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-c constraint_file : a file with arcs marked with + or -
-m --cachefile cachefile: local scores
-d --dump_worklist (bool): default: False
-t --top topN (int): default: 0 - all
""")
#!/usr/bin/env python
import bnsearch
def main(bdtfile, scoretype='BDeu', ess=1.0, outfile=None, cachefile=None):
bn, sc = bnsearch.empty_net(bdtfile, scoretype, ess, cachefile=cachefile)
if outfile:
bn.save(outfile)
print sc.score()
if __name__ == '__main__':
import coliche
coliche.che(
main, ''' bdtfile;
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-o outfile : file to save the model found
-m --cachefile cachefile: local scores
''')
nof_vars = bn0.varc
sc = scorefactory.getscorer(bn.learn.data.Data(bdtfile), scoretype,
ess)
elite = [(-sys.float_info.max, None)] * topN
for bne in eqvnets(bn0):
sc.score_new(bne)
for s, (bnw, seq) in nsearch.nsearch(bne, sc, level, topN, cstrs):
if bnw.arcs() not in elite:
# print "in", bnw.arcs()
weakest = heappushpop(elite, (s, bnw.arcs()))
# print "out", weakest
elite.sort(reverse=True)
if not os.path.exists(resdir): os.mkdir(resdir)
i = 0
for (s, bwe) in elite:
if bwe != None:
bn.bn.BN(nof_vars, bwe,
False).save(os.path.join(resdir, '%d.bn' % i))
i += 1
print s
coliche.che(
main, """bnfile; bdtfile; level (int); topN (int); resdir
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-c constraint_file : a file with arcs marked with + or -
""")
import propreg
import sys
def main(N, p, nof_points=50, nof_reps=10000):
h0 = float(H0)
for f1 in xrange(N+1):
f0 = N-f1
pf1 = C(N,f1)*(p**f1)(1-p)**f0
for
mlines = ("I %s %s" % (, H0), "O %s %s" % (H0, H0))
p0, p1 = propreg.proptest((f0, f1), mlines)
print p, p0
if __name__ == '__main__':
from coliche import che
che(main,
""" N (int); p;
""")
#!/usr/bin/env python
comb = []
def calc_combs(n):
for k in xrange(n+1):
comb.append([1])
for j in xrange(1,k):
comb[k].append(comb[k-1][j-1] + comb[k-1][j])
if k> 0: comb[k].append(1)
def b(N):
B=[]
B.append(1)
for n in xrange(1,N+1):
B.append(0)
for k in xrange(1,n+1):
B[-1]+=(-1)**(k+1)*comb[n][k]*2**(k*(n-k))*B[n-k]
return B[-1]
import sys, math, coliche
def main(n):
calc_combs(n)
nof = b(n)
print(nof, math.log(nof))
coliche.che(main,"n (int)")
-t --tab tabstring : convert tabs to (default:) 8 spaces
-k --keep-empty : consider lines with whitespace only as proper
-n --names names : "GEN", "ROW", "COL" or filename, default "ROW"
-s --start start (int) : if -n GEN : default 0 -> V0, V1, ..
-m --miss missmark : same as -c " .. :: miss miss-mark" : default ""
"""
if __name__ == "__main__":
import varset, varcmd
from coliche import che
din_strusage = ("""
datafile; result_dir;""" + strusage + """
-f --cmd-file cmd-file : read commands from file first
-c --cmd commands : separated by %s
""" + varset.strusage + varcmd.strusage)
r = che(din, din_strusage)
resdir = che(lambda *ps, **ks: ps[1], din_strusage)
print >> file(os.path.join(resdir, "din.cmd"), "w"), " ".join(sys.argv)
ok = r[0]
if ok:
print 1
print r[1], r[2]
else:
print 0
print r[3]
return sum(xp * yp * sum(vrsims(x, y, pprobs, cfgextractors, bnm))
for (x, xp), (y,
yp) in product(zip(xs, xprobs), zip(ys, yprobs)))
def main(vdfile, bnmfile, ifrdir, matrix=False):
valcs = bn.vd.load(vdfile)
bnm = bn.model.bnmodel.load(bnmfile, valcs)
ifr = bn.infer.ifr.load(ifrdir)
pfs = [build_pprobs(ifr, bnm, valcs, i) for i in bnm.bn.vars()]
cfgxs = [build_cfgextractors(bnm.bn, i) for i in bnm.bn.vars()]
dats = [map(int, l.split()) for l in sys.stdin]
N = len(dats)
combs = combinations_with_replacement(enumerate(dats), 2)
if matrix:
K = [[0.0] * N for i in range(N)]
for ((i1, d1), (i2, d2)) in combs:
K[i1][i2] = K[i2][i1] = sim(d1, d2, pfs, cfgxs, bnm)
for i in range(N):
print(' '.join(map(str, K[i])))
else:
for ((i1, d1), (i2, d2)) in combs:
print(i1, i2, sim(d1, d2, pfs, cfgxs, bnm))
if __name__ == '__main__':
from coliche import che
che(main, """vdfile; bnmfile; ifrdir
-m --matrix : print in matrix form""")
#!/usr/bin/env python
import bnsearch
import coliche
def main(bdtfile, ess=1.0, outfile=None):
bn, sc = bnsearch.empty_net(bdtfile, ess)
if outfile:
bn.save(outfile)
print sc.score()
if __name__ == '__main__':
coliche.che(main,
''' bdtfile;
-e --ess ess (float) : default 1.0
-o outfile : file to save the model found''')
raise Exception("Model cannot be out of [0,1]")
io_p = out_p
else:
io_p = in_p
lnom_io = lnom_p(io_p(a,b,f1,N),frqs)
reg_io = R_io(a,b, N, io_p)
lreg_io = math.log(reg_io)
# print io_p(a,b,f1,N), lnom_io, reg_io, lreg_io
lprobs.append((lnom_io != None) and (lnom_io - lreg_io) or None)
if len(lprobs)<2:
raise Exception("At least 2 models required to select among them!")
return logmath.lognorm(lprobs)
if __name__ == '__main__':
import coliche
def main(f0, f1, mfile):
print proptest((f0, f1), file(mfile))
coliche.che(main,
"""
f0 (int) : number of zeros
f1 (int) : number of ones (successes)
mfile : modelfile with lines "[I|O] lower_limit upper_limit"
""")
repfile,
commands=None,
cmd_file=None,
miss_mark="",
**cmdsyntax):
sx = varcmd.syntax(cmdsyntax)
vns = vars.vars(vnfile)
cmds = varcmd.prepend(sx, "miss " + miss_mark, commands)
vscmds = varcmd.varscmds(vns, cmds, sx, cmd_file, ("miss", ))
repf = repfile == "-" and sys.stdout or file(repfile, "w")
for (vcmds, dl) in izip(vscmds, file(datfile)):
acs = vcmds['miss']
nof_mvals = sum(int(d.strip() in acs) for d in dl[:-1].split("\t"))
print >> repf, nof_mvals
if __name__ == "__main__":
from coliche import che
che(
misrep, """
vnfile : the file containing one variable name per row
datfile : the file containing one variable per row
repfile : reports number of missing values per variable
-m --miss miss_mark : same as -c " .. :: miss miss-mark" : default ""
-f --cmd-file cmd-file : read commands from file first
-c --cmd commands : separated by %s
""" + varset.strusage + varcmd.strusage)
'task_index' : '--task-index %d' % task_index,
'cstr' : '-c %s' % cstrfile if cstrfile != None else '',
'ext' : '.exe' if sys.platform == 'win32' else ''
}
scorecmd = """
{binpath/}get_local_scores{ext} {vdfile} {datfile} {score} {rdir/}res {nof_tasks} {task_index} {cstr}
{binpath/}split_local_scores{ext} {nof_vars} {rdir}
{binpath/}reverse_local_scores{ext} {nof_vars} {rdir}
{binpath/}get_best_parents{ext} {nof_vars} {rdir}
{binpath/}get_best_sinks{ext} {nof_vars} {rdir} {rdir/}sinks
{binpath/}get_best_order{ext} {nof_vars} {rdir}/sinks {rdir/}ord
{binpath/}get_best_net{ext} {nof_vars} {rdir} {rdir/}ord {rdir/}net
{binpath/}score_net{ext} {rdir/}net {rdir}
""".format(**kws)
if os.path.exists(resdir):
if not os.path.isdir(resdir):
sys.exit('%s is not a directory' % resir)
else:
os.makedirs(resdir)
subprocess.call(scorecmd, shell=True)
from coliche import che
che(main,
"""vdfile;datfile;score;resdir;
--nof-tasks nof_tasks(int): default: 1
--task-index task_index: default: 0
-c --constraints cstrfile
""")
c_cread = self.libcdata.data_cread
c_cread.restype = c_void_p
self.libcdata.data_nof_vars.argtypes = [c_void_p]
self.libcdata.data_nof_vals.argtypes = [c_void_p, c_int]
open(filename).close() # throws exception if not working
self.dt = c_cread(filename)
def __del__(self):
if self.dt:
pass
# libcdata.data_free(pointer(self.dt))
def nof_vars(self):
return self.libcdata.data_nof_vars(self.dt)
def nof_vals(self, v):
return self.libcdata.data_nof_vals(self.dt, v)
import coliche
def test(bdtfile):
dt = Data(bdtfile)
print dt.nof_vars(), [dt.nof_vals(v) for v in xrange(dt.nof_vars())]
coliche.che(test,'bdtfile')
#!/usr/bin/python
import genctb, deptest
if __name__ == '__main__':
import sys, coliche
def main(pfile, N):
try:
ps = [map(float, l.split()) for l in file(pfile)]
normalizer = sum(map(sum,ps))
ps = [[p/normalizer for p in r] for r in ps]
r = [0,0]
while True:
ctb = genctb.genctb(ps,N)
dt = deptest.deptest_ctb(ctb)
r[dt.index(max(dt))] += 1
print r, float(r[0])/sum(r)
except Exception, msg:
raise
sys.exit("ERROR: "+ str(msg))
coliche.che(main, "pfile; N (int)")
def initial_search_status(bn, scr):
curr_score = scr.score()
return {"scr" : scr,
"curr_bn" : bn,
"curr_score" : curr_score,
"best_bn" : bn.copy(),
"best_score" : curr_score,
"iters" : 0,
"t_no_acts" : 0,
"t_no_acps" : 0,
"t_no_impr" : 0}
def localsearch(search_status, stepping, stopping):
while True :
stepping(search_status)
if stopping(search_status) : break
def empty_net(bdtfile, ess):
libdata = CDLL("/home/tsilande/projects/bn/learn_ctypes/data.so")
data = libdata.data_cread(bdtfile)
bn = BN(libdata.nof_vars(data))
scr = Score(bn, data, ess)
return bn, scr
def main(bdtfile, ess):
bn, scr = empty_net(bdtfile, ess)
print scr.score(), bn.arcs()
if __name__ == '__main__':
coliche.che(main, "bdtfile; ess (float)")
from itertools import izip, count
import sys
import vars, varset, varcmd
def varsel(vnfile, datfile, vnfile_out, datfile_out,
commands = '', cmd_file = None,
**cmdsyntax):
sx = varcmd.syntax(cmdsyntax)
varnames = vars.vars(vnfile)
vscmds = varcmd.varscmds(varnames,commands,sx,cmd_file)
vnf = file(vnfile_out,"w")
datf = file(datfile_out,"w")
for (vl, dl, vcmds) in izip(file(vnfile), file(datfile), vscmds):
if "in" in vcmds:
vnf.write(vl)
datf.write(dl)
if __name__ == "__main__":
from coliche import che
che(varsel,
"""
vnfile : the file containing one variable name per row
datfile : the file containing one variable per row
vnfile-out
datfile-out
-f --cmd-file cmd-file : read commands from file first
-c --cmd commands : separated by %s
""" + varset.strusage + varcmd.strusage)
for qe_tbi in to_be_inserted:
pri = -score + qe_tbi['delta'] + plty * qe_tbi['nof_arcs']
heappush(hq, (pri, qe_tbi))
if max_heap_size > 0 and len(hq) > max_heap_size:
print "truncating hq"
hq = hq[:min_heap_size + 1]
print t, best_score, best_net.arcs()
def main(bdtfile,
ess=1.0,
max_heap_size=5000,
min_heap_size=4000,
max_iters=-1):
data = Data(bdtfile)
qlearn(data, ess, max_heap_size, min_heap_size, max_iters)
if __name__ == '__main__':
import coliche
coliche.che(
main, """
bdtfile : data in bdt-format
-e --ess ess (float) : ESS (default 1.0)
--max_heap_size max_heap_size (int) : give negative for infinite (default 5000)
--min_heap_size min_heap_size (int) : (default 4000)
--max_iters max_iters (int) : give negative for infinite (default -1)
""")
cs = [{} for vn in varnames]
for (vs, cmd, acs) in cmds:
for v in vs:
actions.get(cmd, def_action)(cs[v], cmd, acs)
return cs
strusage = """
--cmd-sep cmd-sep : separator for commands: default "\%s"
--var-cmd-sep var-cmd-sep : token to separate vars and command: default "%s"
""" % (cmd_sep, var_cmd_sep)
# JUST TO TEST
if __name__ == "__main__":
from coliche import che
def main(vnfile, commands="", cmd_file=None, **sx):
sx = syntax(sx)
vns = vars.vars(vnfile)
for t in varscmds(vns, commands, sx, cmd_file):
print t
che(
main, """
vnfile : one variable name per row
-f --cmd-file cmd-file : read commands from file first
-c --cmd commands : separated by %s
""" + strusage)
fromstart = l_to if no_within else l_to+1
for l_from in xrange(fromstart, nof_levels):
for (x,y) in product(xrange(nof_vars), xrange(nof_vars)):
print >>cstrf, '-', x+l_from*nof_vars, y+l_to*nof_vars
cstrf.close()
# create data
if datafile != None and outdatafile != None:
dat = disdat.RowData(vdfile, datafile)
ds = [dat.dats() for l in xrange(nof_levels)]
for l in xrange(nof_levels): # skip initial l from ds[l]
for ll in xrange(l): ds[l].next()
datf = file(outdatafile,'w')
for drows in izip(*ds):
print >>datf, '\t'.join(map(str, chain(*drows)))
datf.close()
if __name__ == '__main__':
import coliche
coliche.che(main,
"""vdfile; outvdfile; constraintfile
-d datafile: datafile
-o outdatafile: outdatafile
-l --levels nof_levels (int) : default:2
--no_within : disallow arcs within timestep
""")
#!/usr/bin/env python
# Check that all forsts have same score
if __name__ == '__main__':
import coliche
import bnsearch
import bestforests
def main(bdtfile, ess=1.0, outfile=None, constraint_file=""):
bn, sc = bnsearch.empty_net(bdtfile, ess)
bestforests.kruskal(bn, sc)
sc.score_new(bn)
print sc.score()
for forest in bestforests.Forest(bn):
sc.score_new(forest)
print sc.score()
coliche.che(
main, ''' bdtfile;
-e --ess ess (float) : default 1.0
''')
if f == t: continue
if op == '+':
sf_must.add(t)
if t in sf_nope:
sf_nope.remove(t)
elif op == '-':
sf_nope.add(t)
if t in sf_must:
sf_must.remove(t)
elif op == '?':
if t in sf_must:
sf_must.remove(t)
if t in sf_nope:
sf_nope.remove(t)
else:
print 'Whaaat?'
for (fn, cs) in cstrs.iteritems():
fi = names.index(fn)
for t in cs[0]:
print '+', fi, t
for t in cs[1]:
print '-', fi, t
if __name__ == "__main__":
import coliche
coliche.che(main, """vdfile
""")
def gen1(ord, bnm):
bns = bnm.bn
d = [0]*len(ord)
for o in ord:
d[o] = wheel(bnm.thetd(o,d))
return d
def gen(bnm, N):
ord = order(bnm.bn)
for n in xrange(N):
yield gen1(ord, bnm)
def main(vdfile, modelfile, N, outfile="-"):
valcs = bn.vd.load(vdfile)
bnm = bnmodel.load(modelfile, valcs)
outf = outfile == "-" and sys.stdout or file(outfile, "w")
for d in gen(bnm, N):
print >> outf, " ".join(map(str, d))
if outfile != "-": outf.close()
if __name__ == '__main__':
from coliche import che
che(main,
'''vdfile; modelfile; N (int)
-o outfile
''')
import networkx as nx
def bn2dg(bn):
dg = nx.DiGraph()
dg.add_nodes_from(bn.vars())
dg.add_edges_from(bn.arcs())
return dg
def is_dag(bn):
dg = bn2dg(bn)
return nx.is_directed_acyclic_graph(dg)
if __name__ == '__main__':
import coliche
from bn.bn import load
def main(bnfile):
print 'DAG' if is_dag(load(bnfile, do_pic=False)) else 'not DAG'
coliche.che(main, 'bnfile')
frqsXY = reduce(operator.__concat__, ctb, [])
lpXY = lognml(frqsXY)
return lpXY
def nml_gi(ctb):
return math.exp(lognml_gi(ctb))
def nml_f(ctb):
return math.exp(lognml_f(ctb))
def deptest_ctb(ctb):
return logmath.lognorm([lognml_gi(ctb), lognml_f(ctb)])
def deptest(ctblines):
return deptest_ctb(contab.get_ctb(ctblines))
if __name__ == '__main__':
import sys, coliche
def main(ctbfile):
try:
ps = deptest(file(ctbfile))
print " ".join(["%.4f" % p for p in ps])
except Exception, msg:
sys.exit("ERROR: "+ str(msg))
coliche.che(main, "ctbfile")
ifr = ifrload(ifrdir)
gen_subsets.use_just_one_set = resdir is None
parsetscores = [get_parsetscores(i, resdir, bnm) for i in bnm.bn.vars()]
potss = [list(gen_subpots(valcs, bnm, ifr, i)) for i in bnm.bn.vars()]
cfgextractors = [get_cfgextractors(i, bnm) for i in bnm.bn.vars()]
dats = [map(int, l.split()) for l in sys.stdin]
combs = combinations_with_replacement(enumerate(dats), 2)
if matrix:
K = [[0.0] * bnm.bn.varc for i in bnm.bn.vars()]
for ((i1, d1), (i2, d2)) in combs:
K[i1][i2] = K[i2][i1] = sim(d1, d2, cfgextractors, parsetscores,
potss)
for i in bnm.bn.vars():
print(' '.join(map(str, K[i])))
else:
for ((i1, d1), (i2, d2)) in combs:
print(i1, i2, sim(d1, d2, cfgextractors, parsetscores, potss))
if __name__ == '__main__':
from coliche import che
che(
main, """vdfile; bnmfile; ifrdir
-r --resdir resdir: directory to get the subsetscores
-c --cix cix (int) : class index counting from 0 : default None
-m --matrix : print in matrix form""")
#!/usr/bin/env python
import bn.bn, data, scorefactory
import coliche
def main(bnfile, bdtfile, scoretype='BDeu', ess=1.0, cachefile=None):
bns = bn.bn.load(bnfile, do_pic=False)
bdt = data.Data(bdtfile)
sc = scorefactory.getscorer(bdt, scoretype, ess, cachefile=cachefile)
sc.score_new(bns)
print sc.score()
if __name__ == '__main__':
coliche.che(
main, ''' bnfile; bdtfile
-g --goodness scoretype BDeu|fNML|AIC|BIC : default: BDeu
-e --ess ess (float) : default 1.0
-m --cachefile cachefile: local scores
''')
dirarcs.add((p2, v))
# move v-structure arcs to urcs
urcs = set()
for (x, y) in bns.arcs():
if (x, y) not in dirarcs:
deorient(x, y, urcs, bns)
# orient what you can
rorient(bns, urcs)
return bns, urcs
def main(bnfile):
bns = bn.bn.load(bnfile)
return naivecause(bns)
if __name__ == '__main__':
import bn, coliche
(bns, urcs) = coliche.che(main, 'bnfile')
for a in bns.arcs():
print "%d -> %d" % a
for (u1, u2) in urcs:
if u1 > u2:
print "%d -- %d" % (u1, u2)
def infer_row(ir, d):
ir.reset()
for i, v in enumerate(d):
if v != -1:
ir.insert_evidence(i, v)
return ir.infer()
def main(ifrdir, infile='', outfile=''):
ir = ifr.load(ifrdir)
inf = sys.stdin if infile == '' else open(infile)
ouf = sys.stdout if outfile == '' else open(outfile, 'w')
for l in inf:
row = map(int, l.split())
dstrs = infer_row(ir, row)
ouf.write('\t'.join(' '.join(map(str, dstr)) for dstr in dstrs) + '\n')
if infile != '': inf.close()
if outfile != '': ouf.close()
coliche.che(
main, """ifrdir
-i --infile infile : default stdin
-o --outfile outfile : default stdout
""")
f1 = sum(s)
f0 = N-f1
p0, p1 = propreg.proptest((f0, f1), mlines)
p0_avg = (r*p0_avg + p0) / (r+1)
p1_avg = (r*p1_avg + p1) / (r+1)
lb0 = f1 * (h0>0.0 and math.log(h0) or 0.0) \
+ f0 * (h0<1.0 and math.log(1-h0) or 0.0)
# lb1 = lfac(f1)+lfac(f0)-lfac(N+1)
# lb1 = lmgprob(f0, f1, 1.0, 1.0)
lb1 = lmgprob(f0, f1, 0.5, 0.5)
b0, b1 = logmath.lognorm((lb0, lb1))
b0_avg = (r*b0_avg + b0) / (r+1)
b1_avg = (r*b1_avg + b1) / (r+1)
print p, p0_avg, b0_avg
if __name__ == '__main__':
from coliche import che
che(main,
""" N (int); H0;
-n --nof-points nof-points (int)
-r --nof-reps nof-reps (int)
""")
