def test_normalization_negative():
def get_normalization_file(filename):
return path.join(path.dirname(__file__), "res", "bug_z_negative",
filename)
domain = Domain.from_file(get_normalization_file("domain"))
support = domain.get_bounds() & read_smtlib(
get_normalization_file("vanilla.support"))
weight = read_smtlib(get_normalization_file("vanilla.weight"))
new_support = read_smtlib(get_normalization_file("renorm.support"))
pa_engine = RejectionEngine(
domain, Iff(new_support, ~normalize_formula(new_support)), Real(1),
1000000)
difference_volume = pa_engine.compute_volume()
assert difference_volume == pytest.approx(0, EXACT_REL_ERROR**2)
support = normalize_formula(support)
new_support = normalize_formula(new_support)
weight = normalize_formula(weight)
engine = XaddEngine(domain, support, weight)
new_weight = engine.normalize(new_support, paths=False)
computed_volume = engine.copy_with(weight=new_weight).compute_volume()
# print(pa_engine.copy_with(support=domain.get_bounds(), weight=new_weight).compute_volume())
# print(pa_engine.copy_with(support=new_support, weight=new_weight).compute_volume())
illegal_volume = engine.copy_with(support=~new_support,
weight=new_weight).compute_volume()
print(computed_volume, illegal_volume)
# new_new_weight = engine.copy_with(support=domain.get_bounds(), weight=new_weight).normalize(new_support, paths=False)
# print(pa_engine.copy_with(support=domain.get_bounds(), weight=new_new_weight).compute_volume())
assert computed_volume == pytest.approx(1, rel=0.1)
assert illegal_volume == pytest.approx(0, rel=EXACT_REL_ERROR)
def execute_script_fname(smtfile):
"""Read and call a Solver to solve the instance"""
print(smtfile)
reset_env()
assert os.path.exists(smtfile)
start = time.clock()
read_smtlib(smtfile)
end = time.clock()
return ( (end - start), smtfile)
def import_wmi_generate_100(filename):
# type: (str) -> Density
queries = [smt.read_smtlib(filename + ".query")]
support = smt.read_smtlib(filename + ".support")
weights = smt.read_smtlib(filename + ".weights")
variables = queries[0].get_free_variables() | support.get_free_variables() | weights.get_free_variables()
domain = Domain.make(real_bounds=(-100, 100),
boolean_variables=[v.symbol_name() for v in variables if v.symbol_type() == smt.BOOL])
return Density(domain, support, weights, queries)
def execute_script_fname(smtfile):
"""Read and call a Solver to solve the instance"""
print(smtfile)
reset_env()
assert os.path.exists(smtfile)
start = time.clock()
read_smtlib(smtfile)
end = time.clock()
return ((end - start), smtfile)
def _read_experiment(path):
input_file = open(path, 'r')
problem_instances = []
for support_name, weights_name, query_name in pickle.load(input_file):
support = read_smtlib(support_name)
weights = read_smtlib(weights_name)
query = read_smtlib(query_name)
problem_instances.append((support, weights, query))
input_file.close()
return problem_instances
def main(filename, sample_count):
seed = time.time()
random.seed(seed)
target_formula = smt.read_smtlib(filename)
variables = target_formula.get_free_variables()
var_names = [str(v) for v in variables]
var_types = {str(v): v.symbol_type() for v in variables}
var_domains = {str(v): (0, 200) for v in variables} # TODO This is a hack
domain = problem.Domain(var_names, var_types, var_domains)
name = basename(filename).split(".")[0]
target_problem = problem.Problem(domain, target_formula, name)
# compute_difference(domain, target_formula, target_formula)
samples = generator.get_problem_samples(target_problem, sample_count, 1)
initial_indices = random.sample(list(range(sample_count)), 20)
learner = KCnfSmtLearner(3, 3, RandomViolationsStrategy(5))
dir_name = "../output/{}".format(name)
img_name = "{}_{}_{}".format(learner.name, sample_count, seed)
# learner.add_observer(plotting.PlottingObserver(data_set.samples, dir_name, img_name, "r0", "r1"))
with open("log.txt", "w") as f:
learner.add_observer(inc_logging.LoggingObserver(f))
print(parse.smt_to_nested(learner.learn(domain, samples, initial_indices)))
def read(path):
with open(path, 'rb') as f:
index = pickle.load(f)
folder = abspath(dirname(path))
model = Model.read(join(folder, index['model_path']))
datasets = {}
for dataset_name, rel_path in index['dataset_paths'].items():
datasets[dataset_name] = Dataset.read(join(folder, rel_path))
bounds = bounds = index['bounds'] if 'bounds' in index else None
learned_supports = []
metadata = None
if 'support_paths' in index:
for support_path in index['support_paths']:
try:
learned_supports.append(
read_smtlib(join(folder, support_path)))
except FileNotFoundError as e:
logger.warning("Couldn't read: {}".format(path))
if 'metadata' in index:
metadata = index['metadata']
problem = Problem(model,
datasets,
bounds=bounds,
learned_supports=learned_supports,
metadata=metadata)
problem.original_path = path
return problem
def import_wmi_mspn(filename):
# type: (str) -> Density
q_file, s_file, w_file = ("{}.{}".format(filename, ext) for ext in ["query", "support", "weight"])
queries = [smt.TRUE()] if not os.path.exists(q_file) else [smt.read_smtlib(q_file)]
support = smt.read_smtlib(s_file)
if os.path.exists(w_file):
weights = smt.read_smtlib(w_file)
else:
weights = smt.Real(1)
name = os.path.basename(filename)
parts = name.split("_")
real_vars = int(parts[1])
bool_vars = int(parts[2])
domain = Domain.make(["A_{}".format(i) for i in range(bool_vars)],
{"x_{}".format(i): [0, 1] for i in range(real_vars)})
return Density(domain, support, weights, queries)
def read(path):
with open(path, 'rb') as f:
index = pickle.load(f)
folder = abspath(dirname(path))
support = read_smtlib(join(folder, index['support_path']))
weightfun = read_smtlib(join(folder, index['weightf_path']))
variables = [
get_env().formula_manager.get_or_create_symbol(varname, vartype)
for varname, vartype in index['variables']
]
bounds = index['bounds']
metadata = None
if 'metadata' in index:
metadata = index['metadata']
return Model(support, weightfun, variables, bounds, metadata=metadata)
def import_problem(filename):
target_formula = smt.read_smtlib(filename)
variables = target_formula.get_free_variables()
var_names = [str(v) for v in variables]
var_types = {str(v): v.symbol_type() for v in variables}
var_domains = {str(v): (None, None)
for v in variables} # TODO This is a hack
return (Domain(var_names, var_types, var_domains)), target_formula
def from_file(cls: 'FileDensity', filename: str) -> 'FileDensity':
def wrap(f):
return os.path.join(filename, f)
if not os.path.exists(filename):
os.makedirs(filename)
domain = Domain.from_file(wrap(cls.get_domain_file()))
support = smt.read_smtlib(wrap(cls.get_support_file()))
weight_file = wrap(cls.get_weight_file())
weight = None
if os.path.exists(weight_file):
weight = smt.read_smtlib(weight_file)
queries = []
query_files = sorted(glob(os.path.join(filename, "query_*.smt2")),
key=lambda f: int(f.split("_")[-1][:-5]))
for query_file in query_files:
queries.append(smt.read_smtlib(query_file))
return FileDensity(domain, support, weight, queries)
def test_read_and_write_shortcuts(self):
fs = get_example_formulae()
fdi, tmp_fname = mkstemp()
os.close(fdi) # Close initial file descriptor
for (f_out, _, _, _) in fs:
write_smtlib(f_out, tmp_fname)
f_in = read_smtlib(tmp_fname)
self.assertEqual(f_out.simplify(), f_in.simplify())
# Clean-up
os.remove(tmp_fname)
def test_read_and_write_shortcuts(self):
fs = get_example_formulae()
fdi, tmp_fname = mkstemp()
os.close(fdi) # Close initial file descriptor
for (f_out, _, _, _) in fs:
write_smtlib(f_out, tmp_fname)
f_in = read_smtlib(tmp_fname)
self.assertEqual(f_out.simplify(), f_in.simplify())
# Clean-up
os.remove(tmp_fname)
def import_problem(name, filename):
target_formula = smt.read_smtlib(filename)
variables = target_formula.get_free_variables()
var_names = [str(v) for v in variables]
var_types = {str(v): v.symbol_type() for v in variables}
var_domains = {str(v): (0, 200) for v in variables} # TODO This is a hack
domain = problem.Domain(var_names, var_types, var_domains)
target_problem = problem.Problem(domain, target_formula, name)
return target_problem
def execute_script_fname(smtfile):
"""Read and print the formula in HR Format."""
reset_env()
assert os.path.exists(smtfile)
smtlib_start = time.clock()
f = read_smtlib(smtfile)
smtlib_end = time.clock()
start = time.clock()
s = f.serialize()
end = time.clock()
assert s is not None
#print(smtfile, (smtlib_end-smtlib_start), (end-start))
return (smtfile, (end - start))
def read(path):
with open(path, 'rb') as f:
index = pickle.load(f)
folder = abspath(dirname(path))
feats, constr = Dataset.read_feats(join(folder, index['feats_path']))
data = Dataset.read_data(join(folder, index['data_path']), feats)
if 'constr_path' in index:
constr2 = read_smtlib(index['constr_path'])
if constr is None:
constr = constr2
else:
constr = And(constr, constr2)
return Dataset(feats, data, constr)
def test_normalization():
def get_normalization_file(filename):
return path.join(path.dirname(__file__), "res", "renorm_bug", filename)
for i in range(5):
domain = Domain.from_file(get_normalization_file("domain.json"))
support = read_smtlib(get_normalization_file("vanilla.support"))
weight = read_smtlib(get_normalization_file("vanilla.weight"))
new_support = read_smtlib(
get_normalization_file("renorm_chi_{}.support".format(i)))
# print(smt_to_nested(support))
clean_support = normalize_formula(support)
clean_new_support = normalize_formula(new_support)
clean_weight = normalize_formula(weight)
print(smt_to_nested(clean_weight))
assert (RejectionEngine(domain, ~Iff(support, clean_support),
Real(1.0), 1000000).compute_volume() == 0)
assert (RejectionEngine(domain, ~Iff(new_support, clean_new_support),
Real(1.0), 1000000).compute_volume() == 0)
# plot_formula("new_support", domain, new_support, ["r0", "r1"])
# plot_formula("clean_new_support", domain, clean_new_support, ["r0", "r1"])
support = clean_support
new_support = clean_new_support
weight = clean_weight
# print(RejectionEngine(domain, Iff(weight, ~clean_weight), Real(1.0), 1000000).compute_volume())
# print(smt_to_nested(support))
print("Problem", i)
engine = XaddEngine(domain, support, weight, "original")
print("Volume before starting", engine.compute_volume())
new_weight = engine.normalize(new_support, paths=False)
Density(domain, new_support, new_weight).to_file("normalized.json")
illegal_volume = XaddEngine(domain, ~new_support, new_weight,
"mass").compute_volume()
assert illegal_volume == pytest.approx(0, rel=EXACT_REL_ERROR)
computed_volume = XaddEngine(domain, TRUE(), new_weight,
"mass").compute_volume()
computed_volume_within = XaddEngine(domain, new_support, new_weight,
"mass").compute_volume()
computed_volume_within2 = XaddEngine(domain, new_support,
new_weight).compute_volume()
computed_volume_within3 = RejectionEngine(domain, new_support,
new_weight,
1000000).compute_volume()
print(
"pa new_support new_weight",
computed_volume_within,
"xadd new_support new_weight:",
computed_volume_within2,
"rej new_support new_weight:",
computed_volume_within3,
)
assert computed_volume_within == pytest.approx(computed_volume_within2,
EXACT_REL_ERROR)
print(
"pa true new_weight:",
computed_volume,
"pa new_support new_weight",
computed_volume_within,
"pa outside new_support new_weight",
illegal_volume,
)
assert computed_volume == pytest.approx(1, rel=EXACT_REL_ERROR)
assert computed_volume_within == pytest.approx(1, rel=EXACT_REL_ERROR)
illegal_volume = engine.copy_with(support=~new_support,
weight=new_weight).compute_volume()
assert illegal_volume == pytest.approx(0, rel=EXACT_REL_ERROR)
def main(filename, sample_count, seed):
random.seed(seed)
target_formula = smt.read_smtlib(filename)
variables = target_formula.get_free_variables()
var_names = [str(v) for v in variables]
var_types = {str(v): v.symbol_type() for v in variables}
var_domains = {
str(v): (0, 1)
for v in variables
} #FIXME: This is a hack. Adjust depending on your benchmarks
domain = problem.Domain(var_names, var_types, var_domains)
name = basename(filename).split(".")[0]
target_problem = problem.Problem(domain, target_formula, name)
samples = generator.get_problem_samples(target_problem, sample_count, 1)
test_samples = generator.get_problem_samples(target_problem, 1000, 1)
kwargs = {"problem": target_problem, "data": samples}
t1 = time.time()
res1 = timeout(search_cnf, kwargs=kwargs, duration=600)
t2 = time.time()
res2 = timeout(search_clause, kwargs=kwargs, duration=600)
t3 = time.time()
res3 = timeout(search_lit, kwargs=kwargs, duration=600)
t4 = time.time()
dur1 = "TO" if res1 is None else t2 - t1
dur2 = "TO" if res2 is None else t3 - t2
dur3 = "TO" if res3 is None else t4 - t3
formula1 = "None" if res1 is None else pretty_print(res1)
formula2 = "None" if res2 is None else pretty_print(res2)
formula3 = "None" if res3 is None else pretty_print(res3)
#FIXME: this will show 1 for timeouts
cl1 = formula1.count("&") + 1
cl2 = formula2.count("&") + 1
cl3 = formula3.count("&") + 1
hl1 = formula1.count("<")
hl2 = formula2.count("<")
hl3 = formula3.count("<")
strat = AllViolationsStrategy()
train_acc1 = "N/A" if res1 is None else (1000 - len(
list(strat.select_active(domain, samples, res1, [])))) / 1000
train_acc2 = "N/A" if res2 is None else (1000 - len(
list(strat.select_active(domain, samples, res2, [])))) / 1000
train_acc3 = "N/A" if res3 is None else (1000 - len(
list(strat.select_active(domain, samples, res3, [])))) / 1000
acc1 = "N/A" if res1 is None else (1000 - len(
list(strat.select_active(domain, test_samples, res1, [])))) / 1000
acc2 = "N/A" if res2 is None else (1000 - len(
list(strat.select_active(domain, test_samples, res2, [])))) / 1000
acc3 = "N/A" if res3 is None else (1000 - len(
list(strat.select_active(domain, test_samples, res3, [])))) / 1000
print("[")
print("file = {}".format(filename))
print("samples= {}".format(sample_count))
print("INCAL_result = {}".format(formula1))
print("SHREC1_result = {}".format(formula2))
print("SHREC2_result = {}".format(formula3))
print("INCAL_time = {}".format(dur1))
print("SHREC1_time = {}".format(dur2))
print("SHREC2_time = {}".format(dur3))
print("INCAL_clauses = {}".format(cl1))
print("SHREC1_clauses = {}".format(cl2))
print("SHREC2_clauses = {}".format(cl3))
print("INCAL_halflines = {}".format(hl1))
print("SHREC1_halflines = {}".format(hl2))
print("SHREC2_halflines = {}".format(hl3))
print("INCAL_cost = {}".format(cl1 + hl1))
print("SHREC1_cost = {}".format(cl2 + hl2))
print("SHREC2_cost = {}".format(cl3 + hl3))
print("INCAL_train_acc = {}".format(train_acc1))
print("SHREC1_train_acc = {}".format(train_acc2))
print("SHREC2_train_acc = {}".format(train_acc3))
print("INCAL_acc = {}".format(acc1))
print("SHREC1_acc = {}".format(acc2))
print("SHREC2_acc = {}".format(acc3))
print("]")
def renormalize(self,
training_data,
seed,
mode=RENORM_OFF,
support=None,
timeout=None,
global_norm=False):
if timeout is None:
timeout = DEF_RENORM_TIMEOUT
detcopy = self.det.copy()
model_support = detcopy.tree_to_WMI_support()
model_weight = detcopy.tree_to_WMI_weightfun()
bounds = {
v.symbol_name(): b
for v, b in detcopy.root.bounds.items() if v.symbol_type() == REAL
}
renorm_support = None
if mode == RENORM_BG_ONLY and training_data.constraints is not None:
renorm_support = training_data.constraints
elif mode == RENORM_FULL:
if training_data.constraints is not None and support is not None:
renorm_support = training_data.constraints & support
elif training_data.constraints is not None:
renorm_support = training_data.constraints
elif support is not None:
renorm_support = support
renormalized = False
if renorm_support is not None:
if global_norm:
logger.debug("Global renormalization")
model_support = model_support & renorm_support
renormalized = True
else:
logger.debug("Local renormalization")
def renorm_wrap(inst, support, support_path, weight_path):
try:
inst.renormalize(support)
support = inst.tree_to_WMI_support()
weight = inst.tree_to_WMI_weightfun()
msg = "Writing result to files:\n{}\n{}"
logger.debug(msg.format(support_path, weight_path))
write_smtlib(support, support_path)
write_smtlib(weight, weight_path)
logger.debug("Done.")
except ModelException as e:
logger.error(
"Couldn't renormalize the DET: {}".format(e))
# communication with wrapper process through file
# NEVER use multiprocessing.Queue with huge pysmt formulas
rndstr = ''.join(choice(TMP_CHARS) for _ in range(TMP_LEN))
support_path = "{}.support".format(rndstr)
weight_path = "{}.weight".format(rndstr)
timed_proc = Process(target=renorm_wrap,
args=(detcopy, renorm_support,
support_path, weight_path))
logger.debug(
"Starting renormalization with timeout: {}".format(
timeout))
timed_proc.start()
logger.debug("Timed proc started")
timed_proc.join(timeout)
logger.debug("Timed proc joined")
if timed_proc.is_alive():
logger.warning("Renormalization timed out")
pid = timed_proc.pid
logger.warning(
"Killing process {} and its children".format(pid))
kill_recursive(pid)
else:
try:
model_support = read_smtlib(support_path)
remove(support_path)
except FileNotFoundError:
model_support = None
try:
model_weight = read_smtlib(weight_path)
remove(weight_path)
except FileNotFoundError:
model_weight = None
if model_support is None or model_weight is None:
raise ModelException("Couldn't renormalize the DET")
logger.debug("Renormalization done")
renormalized = True
model = Model(model_support,
model_weight,
list(map(lambda x: x[0], training_data.features)),
bounds,
metadata=self.learner_args)
# is Z = 1?
if renormalized:
check_Z_normalize(model, seed, TEST_AND_NORM_SAMPLES)
elif not global_norm:
# fallback strategy for local: to global
model, renormalized = self.renormalize(training_data,
seed,
mode=mode,
support=support,
timeout=timeout,
global_norm=True)
return model, renormalized
s.from_file(smtlib_problems[0])
# In[7]:
s.check()
# In[8]:
s.model()
# ## Can we solve with cln?
# In[9]:
root = read_smtlib(smtlib_problems[0])
# In[10]:
root.serialize()
# Generate a model for the smt:
# In[11]:
'''
(! (((1.0 + (skoX * -1.0)) + (skoY * -1.0)) <= skoZ)) &
(
(! (skoZ <= 0.0)) &
(
(! (skoY <= 0.0)) &
(! (skoX <= 0.0))
