def enable_output():
"""Set up competition-compliant output."""
# configure the default global level
borg.get_logger(level = borg.defaults.root_log_level)
# set up output
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(CompetitionFormatter())
handler.setLevel(logging.NOTSET)
logging.root.addHandler(handler)
def enable_output():
"""Set up competition-compliant output."""
# configure the default global level
borg.get_logger(level=borg.defaults.root_log_level)
# set up output
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(CompetitionFormatter())
handler.setLevel(logging.NOTSET)
logging.root.addHandler(handler)
def main(
model_path,
solvers_path,
input_path,
seed = 42,
budget = 3600.0,
cores = 1,
speed = borg.defaults.machine_speed,
quiet = False
):
"""Solve a problem instance."""
# XXX hackish
borg.defaults.machine_speed = speed
try:
# general setup
enable_output()
if not quiet:
borg.get_logger("borg.solvers", level = "DETAIL")
borg.statistics.set_prng_seeds(seed)
# run the solver
bundle = borg.load_solvers(solvers_path)
logger.info("loaded portfolio model from %s", model_path)
with open(model_path) as file:
portfolio = pickle.load(file)
logger.info("solving %s", input_path)
with bundle.domain.task_from_path(input_path) as task:
remaining = budget - borg.get_accountant().total.cpu_seconds
answer = portfolio(task, bundle, borg.Cost(cpu_seconds = remaining), cores)
return bundle.domain.show_answer(task, answer)
except KeyboardInterrupt:
print "\nc terminating on SIGINT"
def main(model_path,
solvers_path,
input_path,
seed=42,
budget=3600.0,
cores=1,
speed=borg.defaults.machine_speed,
quiet=False):
"""Solve a problem instance."""
# XXX hackish
borg.defaults.machine_speed = speed
try:
# general setup
enable_output()
if not quiet:
borg.get_logger("borg.solvers", level="DETAIL")
borg.statistics.set_prng_seeds(seed)
# run the solver
bundle = borg.load_solvers(solvers_path)
logger.info("loaded portfolio model from %s", model_path)
with open(model_path) as file:
portfolio = pickle.load(file)
logger.info("solving %s", input_path)
with bundle.domain.task_from_path(input_path) as task:
remaining = budget - borg.get_accountant().total.cpu_seconds
answer = portfolio(task, bundle, borg.Cost(cpu_seconds=remaining),
cores)
return bundle.domain.show_answer(task, answer)
except KeyboardInterrupt:
print "\nc terminating on SIGINT"
def features_for_path(domain, task_path):
# bring back relevant globals
import os.path
import borg
logger = borg.get_logger(__name__, default_level="INFO")
# collect features
logger.info("getting features of %s", os.path.basename(task_path))
with domain.task_from_path(task_path) as task:
with borg.accounting() as accountant:
(names, values) = domain.compute_features(task)
return (task_path, ["cpu_cost"] + list(names),
[accountant.total.cpu_seconds] + list(values))
def features_for_path(domain, task_path):
# bring back relevant globals
import os.path
import borg
logger = borg.get_logger(__name__, default_level = "INFO")
# collect features
logger.info("getting features of %s", os.path.basename(task_path))
with domain.task_from_path(task_path) as task:
with borg.accounting() as accountant:
(names, values) = domain.compute_features(task)
return (
task_path,
["cpu_cost"] + list(names),
[accountant.total.cpu_seconds] + list(values))
def run_solver_on(suite_path, solver_name, task_path, budget, store_answers,
seed):
"""Run a solver."""
# bring back relevant globals
import os
import borg
logger = borg.get_logger(__name__, default_level="INFO")
if seed is not None:
borg.statistics.set_prng_seeds(seed)
# run the solver
suite = borg.load_solvers(suite_path)
with suite.domain.task_from_path(task_path) as task:
with borg.accounting() as accountant:
answer = suite.solvers[solver_name](task)(budget)
succeeded = suite.domain.is_final(task, answer)
cost = accountant.total.cpu_seconds
logger.info(
"%s %s in %.2f (of %.2f) on %s",
solver_name,
"succeeded" if succeeded else "failed",
cost,
budget,
os.path.basename(task_path),
)
if store_answers:
return (task_path, solver_name, budget, cost, succeeded, answer)
else:
return (task_path, solver_name, budget, cost, succeeded, None)
def run_solver_on(suite_path, solver_name, task_path, budget, store_answers, seed):
"""Run a solver."""
# bring back relevant globals
import os
import borg
logger = borg.get_logger(__name__, default_level="INFO")
if seed is not None:
borg.statistics.set_prng_seeds(seed)
# run the solver
suite = borg.load_solvers(suite_path)
with suite.domain.task_from_path(task_path) as task:
with borg.accounting() as accountant:
answer = suite.solvers[solver_name](task)(budget)
succeeded = suite.domain.is_final(task, answer)
cost = accountant.total.cpu_seconds
logger.info(
"%s %s in %.2f (of %.2f) on %s",
solver_name,
"succeeded" if succeeded else "failed",
cost,
budget,
os.path.basename(task_path),
)
if store_answers:
return (task_path, solver_name, budget, cost, succeeded, answer)
else:
return (task_path, solver_name, budget, cost, succeeded, None)
"""@author: Bryan Silverthorn <*****@*****.**>"""
import os.path
import csv
import uuid
import numpy
import sklearn
import condor
import borg
logger = borg.get_logger(__name__, default_level="INFO")
def evaluate_split(run_data, alpha, split, train_mask, test_mask):
"""Evaluate a model on a train/test split."""
training = run_data.masked(train_mask).collect_systematic([4])
testing = run_data.masked(test_mask).collect_systematic([4])
model = borg.models.MulEstimator(alpha=alpha)(training, 10, training)
score = numpy.mean(borg.models.run_data_log_probabilities(model, testing))
logger.info(
"score at alpha = %.2f given %i runs from %i instances: %f",
alpha,
training.get_run_count(),
len(training),
score,
)
return [alpha, len(training), split, score]
"""@author: Bryan Silverthorn <*****@*****.**>"""
import os
import pty
import subprocess
import borg
log = borg.get_logger(__name__)
def _child_preexec(environment):
"""Run in the child code prior to execution."""
# update the environment
for (key, value) in environment.iteritems():
os.putenv(key, str(value))
# start our own session
os.setsid()
def spawn_pipe_session(arguments, environment = {}, cwd = None):
"""Spawn a subprocess in its own session."""
popened = \
subprocess.Popen(
arguments,
close_fds = True,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE,
preexec_fn = lambda: _child_preexec(environment),
cwd = cwd,
"""@author: Bryan Silverthorn <*****@*****.**>"""
import numpy
import borg
logger = borg.get_logger(__name__, default_level="DETAIL")
def read_median_cost(path):
runs_data = numpy.recfromcsv(path, usemask=True)
return numpy.median(runs_data["cost"])
@borg.annotations()
def main(local_path, train_path):
"""Compute the machine speed calibration ratio."""
local_median = read_median_cost(local_path)
train_median = read_median_cost(train_path)
logger.info("local median run time is %.2f CPU seconds", local_median)
logger.info("model median run time is %.2f CPU seconds", train_median)
logger.info("local speed ratio is thus %f", local_median / train_median)
if __name__ == "__main__":
borg.script(main)
"""@author: Bryan Silverthorn <*****@*****.**>"""
import os.path
import csv
import itertools
import collections
import numpy
import borg
logger = borg.get_logger(__name__, default_level="INFO")
class RunRecord(object):
"""Record of a solver run."""
def __init__(self, solver, budget, cost, success):
"""Initialize."""
self.solver = solver
self.budget = budget
self.cost = cost
self.success = success
def __str__(self):
return str((self.solver, self.budget, self.cost, self.success))
def __repr__(self):
return repr((self.solver, self.budget, self.cost, self.success))
class RunData(object):
"""@author: Bryan Silverthorn <*****@*****.**>"""
import os
import select
import signal
import datetime
import collections
import borg
log = borg.get_logger(__name__)
class SessionTimeAccountant(object):
"""
Track the total CPU (user) time for members of a session.
Process accounting under Linux is a giant pain, especially without root
access. In the general case, it is literally impossible (without patching
the kernel or some such craziness). Whatever. We do our best. Slightly
fancier schemes are available, but they're not much fancier---they're
mostly good only at making it harder for processes to actively evade being
charged. For primarily long-running processes that act in good faith, we
should do ok.
"""
def __init__(self, sid):
"""
Initialize.
"""
self.sid = sid
self.charged = {}
"""@author: Bryan Silverthorn <*****@*****.**>"""
import contextlib
import numpy
import borg
logger = borg.get_logger(__name__, default_level = "DETAIL")
class FakeSolverProcess(object):
"""Provide a solver interface to stored run data."""
def __init__(self, run):
"""Initialize."""
self._run = run
self._elapsed = 0.0
self._terminated = False
def run_then_stop(self, budget):
"""Unpause the solver for the specified duration."""
try:
return self.run_then_pause(budget)
finally:
self.stop()
def run_then_pause(self, budget):
"""Unpause the solver for the specified duration."""
assert not self._terminated
"""@author: Bryan Silverthorn <*****@*****.**>"""
import os.path
import uuid
import subprocess
import condor
import borg
logger = borg.get_logger(__name__, default_level = "DEBUG")
def ground_instance(asp_path, gringo_path, domain_path, ignore_errors, compat):
"""Ground an ASP instance using Gringo."""
# prepare the gringo invocation
(asp_path_base, _) = os.path.splitext(asp_path)
verify_path = "{0}.verify".format(asp_path_base)
command = [gringo_path, domain_path, asp_path]
if compat:
command.append("--compat")
if os.path.exists(verify_path):
command.append(verify_path)
verified = " (and verified)"
else:
verified = ""
logger.debug("running %s", command)
# then ground the instance
