def __learn_io__(networks, setup, configure):
encoding = os.path.join(os.path.dirname(__file__),
'encodings/classify/io.lp')
setup_fs = setup.to_funset()
behaviors = core.LogicalNetworkList.from_hypergraph(networks.hg)
for rep in networks:
found = False
nlist = core.LogicalNetworkList.from_hypergraph(networks.hg, [rep])
for i, behavior in enumerate(behaviors):
blist = core.LogicalNetworkList.from_hypergraph(
networks.hg, [behavior])
fs = setup_fs.union(nlist.concat(blist).to_funset())
instance = ". ".join(map(str, fs)) + "."
clingo = gringo.Control()
if configure is not None:
configure(clingo.conf)
clingo.add("base", [], instance)
clingo.load(encoding)
clingo.ground([("base", [])])
if clingo.solve() == gringo.SolveResult.UNSAT:
found = True
behaviors.add_network(i, rep)
break
if not found:
behaviors.append(rep)
return behaviors
def test():
print("solve something")
c = gringo.Control(["0"])
c.add("base", [], "1{a;b;p(@test2())}.")
c.ground("base", [])
with c.iterSolve() as it:
for m in it:
print m
print("solve something different")
d = gringo.Control(["0"])
d.add("base", [], "1{b;c;p(@test3())}.")
d.ground("base", [])
with d.iterSolve() as it:
for m in it:
print m
def ground(kind):
global control, scratch, verbose, sources, options, objects, horizon
count = objects+horizon+1
parts = [("expand", [count])]
if scratch and count > 1:
control = gringo.Control()
for source in sources: control.load(source)
for i in range(0,objects): parts.append(("object", [i+1, count]))
for i in range(0,horizon): parts.append(("horizon", [i+1, count]))
if scratch or count == 1:
for option in options: setattr(control.conf, option[0], option[1])
parts.append(("base", []))
if kind:
objects += 1
parts.append(("object", [objects, count]))
else:
horizon += 1
parts.append(("horizon", [horizon, count]))
if verbose:
print
print "Objects:", objects
print "Horizon:", horizon
control.ground(parts)
if verbose:
print "Solving:", count
def __get_clingo__(self, encodings, args=None):
clingo = gringo.Control(args or [])
clingo.add("base", [], self.instance)
for enc in encodings:
clingo.load(self.encodings[enc])
return clingo
def __init__(self):
self.k = 0
self.prg = gringo.Control()
self.prg.load("client.lp")
self.prg.ground([("pigeon", []), ("sleep", [self.k])])
self.prg.assign_external(Fun("sleep", [self.k]), True)
self.ret = SolveResult.UNKNOWN
self.models = []
def control(self, size=0, configure=None):
"""
Finds all inclusion-minimal intervention strategies up to the given size.
Intervention strategies found are saved in the attribute :attr:`strategies`
as a :class:`caspo.core.clamping.ClampingList` object instance.
Example::
>>> from caspo import core, control
>>> networks = core.LogicalNetworkList.from_csv('networks.csv')
>>> scenarios = control.ScenarioList('scenarios.csv')
>>> controller = control.Controller(networks, scenarios)
>>> controller.control()
>>> controller.strategies.to_csv('strategies.csv')
Parameters
----------
size : int
Maximum number of intervention per intervention strategy
configure : callable
Callable object responsible of setting clingo configuration
"""
self._strategies = []
clingo = gringo.Control(['-c maxsize=%s' % size])
clingo.conf.solve.models = '0'
if configure:
def overwrite(args, proxy):
for i in xrange(args.threads):
proxy.solver[i].no_lookback = 'false'
proxy.solver[i].heuristic = 'domain'
proxy.solver[i].dom_mod = '5,16'
configure(clingo.conf, overwrite)
else:
clingo.conf.solver.no_lookback = 'false'
clingo.conf.solver.heuristic = 'domain'
clingo.conf.solver.dom_mod = '5,16'
clingo.conf.solve.enum_mode = 'domRec'
clingo.add("base", [], self.instance)
clingo.load(self.encodings['control'])
clingo.ground([("base", [])])
clingo.solve(on_model=self.__save__)
self.stats['time_optimum'] = clingo.stats['time_solve']
self.stats['time_enumeration'] = clingo.stats['time_total']
self._logger.info("%s optimal intervention strategies found in %.4fs", len(self._strategies), self.stats['time_enumeration'])
self.strategies = core.ClampingList(self._strategies)
def __init__(self, script_args, control_args):
Solver.__init__(self, script_args)
self.__prg = gringo.Control(control_args)
self.add_const(self.__prg)
for f in script_args.file:
self.__prg.load(f)
self.__prg.add("check", ["t"], "#external query(t).")
self.__future = None
def default_control(self, *args):
control = gringo.Control(
["--conf=trendy", "--stats", "--opt-strat=usc"] + list(args))
for f in self.domain:
control.load(f)
control.load(aspf("supportConsistency.lp"))
control.load(aspf("normalize.lp"))
control.add("base", [], self.data)
return control
def __init__(self, connection):
Thread.__init__(self)
self.k = 0
self.prg = gringo.Control()
self.prg.load("client.lp")
self.prg.ground([("pigeon", []), ("sleep", [self.k])])
self.prg.assign_external(Fun("sleep", [self.k]), True)
self.state = SolveThread.STATE_IDLE
self.input = Connection()
self.output = connection
def solve(self):
locale.setlocale(locale.LC_ALL, 'C')
ctl = gringo.Control(['-Wno-atom-undefined','-t8'])
ctl.load(self.aspfile)
#ctl.conf.solve.models = 0 if self.solveMode in ["all","optN"] else self.solveMode
#if self.solveMode == 'optN':
# ctl.conf.solve.opt_mode = 'optN'
ctl.ground([("base", [])])
#self.result = ctl.solve(assumptions = None, on_model = self.__on_model)
ctl.solve(assumptions = None, on_model = self.__on_model)
print(ctl.stats['time_total'],ctl.stats['lp']['atoms'])
def storygen(characters):
prg = gringo.Control()
prg.load("story.lp")
prg.ground([("base", [])])
res = prg.solve(None, on_model)
print("solving...")
print(story)
while True:
if story:
if (len(story) / 5) == scenes:
return story
def default_control(self, *args):
control = gringo.Control(["--conf=trendy", "--stats",
"--opt-strat=usc"] + list(args))
for f in self.domain:
control.load(f)
if not self.nodataset:
control.load(aspf("supportConsistency.lp"))
control.load(aspf("normalize.lp"))
control.add("base", [], self.data)
if self.opts.clingo_parallel_mode:
control.conf.solve.parallel_mode = self.opts.clingo_parallel_mode
return control
def __init__(self):
self.size = 1
self.blocked = set()
self.barriers = set()
self.targets = set()
self.pos = dict()
self.robots = [{}]
self.moves = []
self.current_target = None
self.solution = None
ctl = gringo.Control()
ctl.load("board.lp")
ctl.ground([("base", [])])
ctl.solve(on_model=self.__on_model)
def __init__(self, horizon=0):
self.__horizon = horizon
self.__prg = gringo.Control(['-t4'])
self.__future = None
self.__solution = None
self.__assign = []
self.__prg.load("board.lp")
self.__prg.load("robots.lp")
parts = [("base", []), ("check", [0]), ("state", [0])]
for t in range(1, self.__horizon + 1):
parts.extend([("trans", [t]), ("check", [t]), ("state", [t])])
self.__prg.ground(parts)
self.__prg.assign_external(gringo.Fun("horizon", [self.__horizon]),
True)
def compute_backdoor(l, threads):
if threads:
raise NotImplemented
logging.info('Generate LP instance')
ctl = gringo.Control()
ctl.load("vc.lp")
logging.info('Grounding rules')
define_edges(l, ctl)
ctl.ground([("base", [])])
logging.info('Solving LP instance...')
vc = AnswerSet()
f = ctl.solve_async(on_model=vc.update_model)
f.wait()
logging.warning('=' * 80)
logging.warning('Solution value = %s', vc.optimization)
return imap(lambda x: l.symtab.tab[x], vc.iter_edges())
def start(self, step):
self.__prg = gringo.Control(self.__control_args)
self.add_const(self.__prg)
for f in self.__script_args.file:
self.__prg.load(f)
self.__prg.add("base", [], "query({0}).".format(step))
self.__step = step
for i in range(0, step + 1):
parts = []
parts.append(("check", [i]))
if i > 0:
parts.append(("step", [i]))
self.__prg.cleanup_domains()
else:
parts.append(("base", []))
self.__prg.ground(parts)
self.__future = self.__prg.solve_async(on_finish=self.on_finish)
def solve(aspFile, solveMode, task):
print('test')
solvingTime = 0.0
grndPrgSize = 0.0
locale.setlocale(locale.LC_ALL, 'C')
ctl = gringo.Control(['-Wno-atom-undefined','-t8'])
ctl.load(aspFile)
ctl.conf.solve.models = 0 if solveMode in ["all","optN"] else solveMode
if solveMode == 'optN':
ctl.conf.solve.opt_mode = 'optN'
ctl.ground([("base", [])])
result = ctl.solve(assumptions = None, on_model = __on_model)
if task == 'score_rules':
solvingTime = ctl.stats['time_total']
grndPrgSize = ctl.stats['lp']['atoms']
print(solvingTime)
return (result,solvingTime,grndPrgSize)
def solve(self):
#cores = '-t%d'%(self.getCores())
locale.setlocale(locale.LC_ALL, 'C')
ctl = gringo.Control(['-Wno-atom-undefined','-t4'])
ctl.load(self.aspfile)
ctl.conf.solve.models = 0 if self.solveMode in ["all","optN"] else self.solveMode
if self.solveMode == 'optN':
ctl.conf.solve.opt_mode = 'optN'
ctl.ground([("base", [])], functions)
#f = ctl.solve_async(assumptions = None, on_model = self.__on_model, on_finish = self.__on_finish)
#f.wait()
self.result = ctl.solve(assumptions = None, on_model = self.__on_model)
#print(ctl.stats.keys())
#for k in ctl.stats.keys():
# print(k,ctl.stats[k])
if self.task == 'score_rules':
self.solvingTime = ctl.stats['time_total']
self.grndPrgSize = ctl.stats['lp']['atoms']
def solve(self):
# There is a very strange behaviour with parallel mode (-t): When running
# experiments in parallel, there were cases when unnecessary use3 atoms
# were included in an answer set. This happened only with -t on. The
# unnecessary atoms lead to NoSuchElement exceptions (when trying to retrieve)
# the corresponding literal from the map, or to wrong rules.
# This happened only when running experiments in parallel, when running ILED in
# a single core the -t option works fine and its ok to use it (it also speeds
# up the application in cases that you'd have to wait for hours -- at best--
# to get an answer).
# ctl = gringo.Control(['-Wno-atom-undefined','-t8']) # -t8: run in parallel using 8 threads
ctl = gringo.Control(['-Wno-atom-undefined'])
#ctl = gringo.Control()
ctl.load(self.aspfile)
ctl.conf.solve.models = 0
if self.solveMode == 'optN':
ctl.conf.solve.opt_mode = 'optN'
ctl.ground([("base", [])])
#f = ctl.solve_async(assumptions = None, on_model = self.__on_model, on_finish = self.__on_finish)
#f.wait()
self.result = ctl.solve(assumptions=None, on_model=self.__on_model)
#!/usr/bin/env python
import gringo
print "to begin with"
a = gringo.Control(["0"])
a.add(
"base", [], """
#script(python)
def test2():
return 42
#end.
1{a;b;p(@test2())}.
""")
a.ground("base", [])
a.solve()
with a.iterSolve() as it:
for m in it:
print m
def test3():
return 23
def test():
print("solve something")
c = gringo.Control(["0"])
c.add("base", [], "1{a;b;p(@test2())}.")
c.ground("base", [])
with c.iterSolve() as it:
#!/usr/bin/env python
import gringo
import json
import sys
control = gringo.Control()
scratch = False
outputs = True
statist = False
verbose = False
sources = []
options = []
objects = 0
horizon = 0
end = 0
def info():
print "Usage: main.py [--scratch] [--quiet] [--stats] [--verbose] [--maxobj=n] [--option=\"<option key> <option value>\"]* [logic program files]+"
print "Example: main.py --scratch --quiet --stats --verbose --maxobj=42 --option=\"solve.models 0\" encoding.lp instance.lp"
def show(model):
global outputs
if outputs: print "Model: ", model.atoms()
def ground(kind):
urwid.connect_signal(ba, 'click', c.prev)
sf = urwid.Text("")
b = urwid.Columns([sf, ('fixed', len(bc.label) + 4, bc), ('fixed', len(ba.label) + 4, ba), ('fixed', len(bb.label) + 4, bb), sf], 1)
f = urwid.Frame(urwid.Filler(c.display), None, b, 'footer')
palette = [
('red', 'black', 'light red'),
('green', 'black', 'light green'),
('blue', 'black', 'light blue'), ]
self.loop = urwid.MainLoop(f, palette)
self.loop.run()
c = gringo.Control()
c.add("check", ["k"], "#external query(k).")
for f in sys.argv[1:]: c.load(f)
def make_on_model(field, stone, move, target):
def on_model(m):
for atom in m.atoms(gringo.Model.ATOMS):
if atom.name() == "field" and len(atom.args()) == 2:
x, y = atom.args()
field.append((x, y))
elif atom.name() == "stone" and len(atom.args()) == 5:
s, d, x, y, l = atom.args()
stone.append((str(s), str(d), x, y, l))
elif atom.name() == "move" and len(atom.args()) == 4:
t, s, d, xy = atom.args()
move.setdefault(t, []).append((str(s), str(d), xy))
elif atom.name() == "target" and len(atom.args()) == 3:
directory = os.path.join(path, results)
#print(directory, end='')
#shutil.rmtree(directory, ignore_errors=True)
try:
#for the_file in os.listdir(directory):
# file_path = os.path.join(directory, the_file)
# if os.path.isfile(file_path):
# os.unlink(file_path)
os.makedirs(directory)
except Exception, e:
pass
#print(e)
for i in datasets:
print(i, end=',')
#help(gringo)
control = gringo.Control(
["--conf=trendy", "--stats", "0", "--opt-strat=usc"])
#print_conf(control.conf, "")
control.load("guessBN.lp")
control.load(encoding)
control.load("minimizeWeightOnly.lp")
control.load("normalize.lp")
# control.load("../../Benchmarks/nets_to_test/1/asp/pkn.lp")
control.load(os.path.join(path, pkn))
control.load(os.path.join(path, i))
control.ground([("base", [])])
control.load("show.lp")
control.ground([("show", [])])
control.assign_external(gringo.Fun("tolerance"), False)
start = time.time()
def design(self,
max_stimuli=-1,
max_inhibitors=-1,
max_experiments=10,
relax=False,
configure=None):
"""
Finds all optimal experimental designs using up to :attr:`max_experiments` experiments, such that each experiment has
up to :attr:`max_stimuli` stimuli and :attr:`max_inhibitors` inhibitors. Each optimal experimental design is appended in the
attribute :attr:`designs` as an instance of :class:`caspo.core.clamping.ClampingList`.
Example::
>>> from caspo import core, design
>>> networks = core.LogicalNetworkList.from_csv('behaviors.csv')
>>> setup = core.Setup.from_json('setup.json')
>>> designer = design.Designer(networks, setup)
>>> designer.design(3, 2)
>>> for i,d in enumerate(designer.designs):
... f = 'design-%s' % i
... d.to_csv(f, stimuli=self.setup.stimuli, inhibitors=self.setup.inhibitors)
Parameters
----------
max_stimuli : int
Maximum number of stimuli per experiment
max_inhibitors : int
Maximum number of inhibitors per experiment
max_experiments : int
Maximum number of experiments per design
relax : boolean
Whether to relax the full-pairwise networks discrimination (True) or not (False).
If relax equals True, the number of experiments per design is fixed to :attr:`max_experiments`
configure : callable
Callable object responsible of setting clingo configuration
"""
self.designs = []
args = [
'-c maxstimuli=%s' % max_stimuli,
'-c maxinhibitors=%s' % max_inhibitors, '-Wno-atom-undefined'
]
clingo = gringo.Control(args)
clingo.conf.solve.opt_mode = 'optN'
if configure is not None:
configure(clingo.conf)
clingo.add("base", [], self.instance)
clingo.load(self.encodings['design'])
clingo.ground([("base", [])])
if relax:
parts = [("step", [step])
for step in xrange(1, max_experiments + 1)]
parts.append(("diff", [max_experiments + 1]))
clingo.ground(parts)
ret = clingo.solve(on_model=self.__save__)
else:
step, ret = 0, gringo.SolveResult.UNKNOWN
while step <= max_experiments and ret != gringo.SolveResult.SAT:
parts = []
parts.append(("check", [step]))
if step > 0:
clingo.release_external(gringo.Fun("query", [step - 1]))
parts.append(("step", [step]))
clingo.cleanup_domains()
clingo.ground(parts)
clingo.assign_external(gringo.Fun("query", [step]), True)
ret, step = clingo.solve(on_model=self.__save__), step + 1
self.stats['time_optimum'] = clingo.stats['time_solve']
self.stats['time_enumeration'] = clingo.stats['time_total']
self._logger.info("%s optimal experimental designs found in %.4fs",
len(self.designs), self.stats['time_enumeration'])
def __init__(self, fpath):
self._prg = gringo.Control()
self._prg.conf.solve.models = 0
self._prg.load(fpath)
self._prg.ground([("base", [])])
