def encode_graph(g,manager):
print "encoding graphs ..."
start = time()
sdd.sdd_manager_auto_gc_and_minimize_off(manager) # ACACAC
alpha = _encode_graph(g,manager)
print "done! (%.3fs)" % (time()-start)
print "model count..."
print "sdd mc :", sdd.sdd_model_count(alpha,manager)
print "sdd mc-g:", global_model_count(alpha,manager)
#print "minimizing ..."
#sdd.sdd_ref(alpha,manager)
#sdd.sdd_manager_minimize(manager)
#sdd.sdd_deref(alpha,manager)
print "sdd size:", sdd.sdd_size(alpha)
print "sdd nc :", sdd.sdd_count(alpha)
return alpha
def convert(filename):
start = time.time()
manager,alpha = orig.parse_bdd(filename+".zdd")
end = time.time()
print " sdd node count: %d" % sdd.sdd_count(alpha)
print " sdd size: %d" % sdd.sdd_size(alpha)
print " sdd model count: %d" % sdd.sdd_model_count(alpha,manager)
print " global model count: %d" % orig.global_model_count(alpha,manager)
print " read bdd time: %.3fs" % (end-start)
sdd.sdd_save(filename + ".sdd",alpha)
#sdd.sdd_save_as_dot(filename +".sdd.dot",alpha)
vtree = sdd.sdd_manager_vtree(manager)
sdd.sdd_vtree_save(filename + ".vtree",vtree)
#sdd.sdd_vtree_save_as_dot(filename +".vtree.dot",vtree)
print "===================="
print "before garbage collecting..."
print "live size:", sdd.sdd_manager_live_count(manager)
print "dead size:", sdd.sdd_manager_dead_count(manager)
print "garbage collecting..."
sdd.sdd_manager_garbage_collect(manager)
print "live size:", sdd.sdd_manager_live_count(manager)
print "dead size:", sdd.sdd_manager_dead_count(manager)
def update(self, alpha):
size = sdd.sdd_size(alpha)
self.count += 1
if size < self.min_size: self.min_size = size
if size > self.max_size: self.max_size = size
self.sum_size += size
def run():
with timer.Timer("reading dataset"):
dataset = util.read_binary_dataset(test_filename)
domain = util.read_header(test_filename)
'''
if OPTIONS.majority_circuit_opt:
l = len(domain)
for k in xrange(num_trees):
domain["Tree_%d" % k] = l+k
'''
with timer.Timer("initializing manager"):
# start sdd manager
var_count = len(domain) - 1
vtree = sdd.sdd_vtree_new(var_count, "balanced")
manager = sdd.sdd_manager_new(vtree)
#sdd.sdd_manager_auto_gc_and_minimize_on(manager)
#sdd.sdd_manager_auto_gc_and_minimize_off(manager)
sdd_state = SddState(vtree, manager)
with timer.Timer("reading constraints"):
constraint_sdd, constraint_info = encode_logical_constraints(
constraint_filename, manager, domain)
sdd.sdd_ref(constraint_sdd, manager)
with timer.Timer("reading trees"):
tree_states = []
for filename in sorted(glob.glob(tree_basename.replace('%d', '*'))):
tree = pygv.AGraph(filename)
tree_state = TreeState(tree, domain, constraint_info)
tree_states.append(tree_state)
#tree.layout(prog='dot')
#tree.draw(filename+".png")
#num_trees = len(tree_states)
with timer.Timer("compiling trees"):
forest_sdds, _ = izip(*forest_sdds_iter(tree_states, sdd_state))
#forest_sdds = list(forest_sdds_iter(tree_states,sdd_state))
forest_sdds = [
(tree_state, tree_sdd)
for tree_state, tree_sdd in zip(tree_states, forest_sdds)
]
cmpf = lambda x, y: cmp(sdd.sdd_size(x[1]), sdd.sdd_size(y[1]))
forest_sdds.sort(cmp=cmpf)
tree_states = [tree_state for tree_state, tree_sdd in forest_sdds]
#ACACAC
sdd.sdd_manager_auto_gc_and_minimize_off(manager)
sdd.sdd_manager_minimize_limited(manager)
stats = SddSizeStats()
for tree_state, tree_sdd in forest_sdds:
stats.update(tree_sdd)
sdd.sdd_deref(tree_sdd, manager)
sdd.sdd_manager_garbage_collect(manager)
forest_sdds, used_vars_list = izip(
*forest_sdds_iter(tree_states, sdd_state))
print stats
with timer.Timer("compiling all", prefix="| "):
alpha = compile_all(forest_sdds, used_vars_list, num_trees, domain,
manager, constraint_sdd)
with timer.Timer("evaluating"):
msg = util.evaluate_dataset_all_sdd(dataset, alpha, manager)
print "| trees : %d" % num_trees
print "--- evaluating majority vote on random forest (compiled):"
print msg
print "| all size :", sdd.sdd_size(alpha)
print "| all count:", sdd.sdd_count(alpha)
print " model count:", sdd.sdd_global_model_count(alpha, manager)
with timer.Timer("checking monotonicity"):
result = is_monotone(alpha, manager)
print "Is monotone?", result
#for tree_sdd in forest_sdds: sdd.sdd_deref(tree_sdd,manager)
print "===================="
print "before garbage collecting..."
print "live size:", sdd.sdd_manager_live_count(manager)
print "dead size:", sdd.sdd_manager_dead_count(manager)
print "garbage collecting..."
sdd.sdd_manager_garbage_collect(manager)
print "live size:", sdd.sdd_manager_live_count(manager)
print "dead size:", sdd.sdd_manager_dead_count(manager)
vtree = sdd.sdd_manager_vtree(manager)
print "Writing sdd file %s and vtree file %s" % (sdd_filename,
vtree_filename)
sdd.sdd_save(sdd_filename, alpha)
sdd.sdd_vtree_save(vtree_filename, vtree)
print "Writing constraint sdd file %s and constraint vtree file %s" % (
constraint_sdd_filename, constraint_vtree_filename)
sdd.sdd_save(constraint_sdd_filename, constraint_sdd)
sdd.sdd_vtree_save(constraint_vtree_filename, vtree)
########################################
if __name__ == '__main__':
import sys
if len(sys.argv) != 2:
print "usage: %s [BDD_FILENAME]" % sys.argv[0]
exit(1)
filename = sys.argv[1]
start = time.time()
manager,alpha = parse_bdd(filename)
end = time.time()
print " sdd node count: %d" % sdd.sdd_count(alpha)
print " sdd size: %d" % sdd.sdd_size(alpha)
print " sdd model count: %d" % sdd.sdd_model_count(alpha,manager)
print " global model count: %d" % global_model_count(alpha,manager)
print " read bdd time: %.3fs" % (end-start)
"""
sdd.sdd_ref(alpha,manager)
start = time.time()
sdd.sdd_manager_minimize(manager)
end = time.time()
print " min sdd node count: %d" % sdd.sdd_count(alpha)
print " min sdd time: %.3fs" % (end-start)
sdd.sdd_deref(alpha,manager)
"""
sdd.sdd_save(filename + ".sdd",alpha)
if __name__ == '__main__':
import sys
if len(sys.argv) != 4:
print "usage: %s [GRID-M] [GRID-N] [MIDPOINT]" % sys.argv[0]
exit(1)
m,n,midpoint = int(sys.argv[1]),int(sys.argv[2]),int(sys.argv[3])
filename = fnPrefix = ("graphs/asdf-%d-%d-%d" % (m,n,midpoint))
filenameNoMP = fnPrefixNoMP = ("graphs/asdf-no-mp-%d-%d-%d" % (m,n,midpoint))
start = time.time()
manager,alpha = parse_bdd(filename+".zdd")
end = time.time()
print " sdd node count: %d" % sdd.sdd_count(alpha)
print " sdd size: %d" % sdd.sdd_size(alpha)
print " sdd model count: %d" % sdd.sdd_model_count(alpha,manager)
print " global model count: %d" % global_model_count(alpha,manager)
print " read bdd time: %.3fs" % (end-start)
start = time.time()
managerNoMP,alphaNoMP = parse_bdd(filenameNoMP+".zdd")
end = time.time()
print " sdd node count: %d" % sdd.sdd_count(alphaNoMP)
print " sdd size: %d" % sdd.sdd_size(alphaNoMP)
print " sdd model count: %d" % sdd.sdd_model_count(alphaNoMP,managerNoMP)
print " global model count: %d" % global_model_count(alphaNoMP,managerNoMP)
print " read bdd time: %.3fs" % (end-start)
"""
sdd.sdd_ref(alpha,manager)
