def test_order(self):
domain = Domain(["s1", "s2"], {"s1": REAL, "s2": BOOL}, {"s1": (0, 1)})
data = np.array([[1, 0], [0, 1]])
a, b = domain.get_symbols(["s1", "s2"])
f = (a >= 1) & ~b
assert all(evaluate(domain, f, data) == np.array([1, 0]))
def test_order(self):
domain = Domain(["s1", "s2"], {"s1": REAL, "s2": BOOL}, {"s1": (0, 1)})
data1 = np.array([1, 0])
data2 = np.array([0, 1])
a, b = domain.get_symbols(["s1", "s2"])
f = (a >= 1) & ~b
assert evaluate(domain, f, data1) == np.array([1])
assert evaluate(domain, f, data2) == np.array([0])
def bool_xor_problem():
variables = ["a", "b"]
var_types = {"a": BOOL, "b": BOOL}
var_domains = dict()
domain = Domain(variables, var_types, var_domains)
a, b = (domain.get_symbol(v) for v in variables)
theory = (a & ~b) | (~a & b)
return domain, theory, "2xor"
def ice_cream_problem():
variables = ["chocolate", "banana", "weekend"]
chocolate, banana, weekend = variables
var_types = {chocolate: REAL, banana: REAL, weekend: BOOL}
var_domains = {chocolate: (0, 1), banana: (0, 1)}
domain = Domain(variables, var_types, var_domains)
chocolate, banana, weekend = (domain.get_symbol(v) for v in variables)
theory = (chocolate < 0.650) \
& (banana < 0.550) \
& (chocolate + 0.7 * banana <= 0.700) \
& (chocolate + 1.2 * banana <= 0.750) \
& (~weekend | (chocolate + 0.7 * banana <= 0.340))
return domain, theory, "ice_cream"
def test_projection():
domain = Domain.make(["a", "b"], ["x", "y"], real_bounds=(0, 1))
data = numpy.array([
[1, 0, 0.5, 0.3],
[0, 0, 0.2, 0.1],
])
# Get boolean variables
domain1, data1 = domain.project(["a", "b"], data)
assert domain1.variables == ["a", "b"]
assert (data1 == numpy.array([
[1, 0],
[0, 0],
])).all()
# Get real variables
domain2, data2 = domain.project(["x", "y"], data)
assert domain2.variables == ["x", "y"]
assert (data2 == numpy.array([
[0.5, 0.3],
[0.2, 0.1],
])).all()
# Reorder variables
domain3, data3 = domain.project(["x", "a"], data)
assert domain3.variables == ["x", "a"]
assert (data3 == numpy.array([
[0.5, 1],
[0.2, 0],
])).all()
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 background_knowledge_example():
domain = Domain.make(["a", "b"], ["x", "y"], [(0, 1), (0, 1)])
a, b, x, y = domain.get_symbols(domain.variables)
formula = (a | b) & (~a | ~b) & (x >= 0) & (x <= y) & (y <= 1)
thresholds = {v: 0.1 for v in domain.real_vars}
data = uniform(domain, 10000)
labels = evaluate(domain, formula, data)
data = data[labels == 1]
labels = labels[labels == 1]
def learn_inc(_data, _labels, _i, _k, _h):
strategy = OneClassStrategy(
RandomViolationsStrategy(10),
thresholds) #, background_knowledge=(a | b) & (~a | ~b))
learner = KCnfSmtLearner(_k, _h, strategy, "mvn")
initial_indices = LearnOptions.initial_random(20)(list(
range(len(_data))))
# learner.add_observer(LoggingObserver(None, _k, _h, None, True))
learner.add_observer(
PlottingObserver(domain, "test_output/bg",
"run_{}_{}_{}".format(_i, _k,
_h), domain.real_vars[0],
domain.real_vars[1], None, False))
return learner.learn(domain, _data, _labels, initial_indices)
(new_data, new_labels,
formula), k, h = learn_bottom_up(data, labels, learn_inc, 1, 1, 1, 1,
None, None)
print("Learned CNF(k={}, h={}) formula {}".format(k, h,
pretty_print(formula)))
print("Data-set grew from {} to {} entries".format(len(labels),
len(new_labels)))
def test_minus():
domain = Domain.make([], ["x"], [(0, 1)])
(x, ) = domain.get_symbols()
support = TRUE()
weight = Real(1) - x
engine = XaddEngine(domain, support, weight)
assert engine.compute_volume() is not None
def sanity_b0_r1():
domain = Domain.make(real_variables=["x"], real_bounds=(0, 1))
x, = domain.get_symbols()
support = (x >= 0.25) & (x <= 0.75)
weight = x + 1
queries = [x >= 0.5]
return Density(domain, support, weight, queries)
def sanity_b1_r0():
domain = Domain.make(["a"])
a, = domain.get_symbols()
support = TRUE()
weight = Ite(a, Real(0.3), Real(0.7))
queries = [a, ~a]
return Density(domain, support, weight, queries)
def test_sampling():
domain = Domain.make(["a", "b"], ["x", "y"], real_bounds=(0, 1))
a, b, x, y = domain.get_symbols()
support = (a | b) & (~a | ~b) & (x <= y)
weight = smt.Ite(a, smt.Real(1), smt.Real(2))
required_sample_count = 10000
samples_weighted, pos_ratio = positive(required_sample_count, domain,
support, weight)
assert samples_weighted.shape[0] == required_sample_count
assert sum(evaluate(domain, support,
samples_weighted)) == len(samples_weighted)
samples_a = sum(evaluate(domain, a, samples_weighted))
samples_b = sum(evaluate(domain, b, samples_weighted))
assert samples_a == pytest.approx(samples_b / 2, rel=0.2)
assert pos_ratio == pytest.approx(0.25, rel=0.1)
samples_unweighted, pos_ratio = positive(required_sample_count, domain,
support)
assert samples_unweighted.shape[0] == required_sample_count
assert sum(evaluate(domain, support,
samples_unweighted)) == len(samples_weighted)
samples_a = sum(evaluate(domain, a, samples_unweighted))
samples_b = sum(evaluate(domain, b, samples_unweighted))
assert samples_a == pytest.approx(samples_b, rel=0.1)
assert pos_ratio == pytest.approx(0.25, rel=0.1)
def triangle(nvars, rand_gen):
# alpha = rand_gen.uniform(0.05, 0.25)
alpha = rand_gen.uniform(0.2, 0.25)
remain = nvars % 3
n_tris = int(nvars / 3)
variables = [Symbol(f"x{i}", REAL) for i in range(1, nvars + 1)]
lbounds = [LE(Real(0), x) for x in variables]
ubounds = [LE(x, Real(1)) for x in variables]
clauses = []
potentials = []
for i in range(n_tris):
x, y, z = variables[3 * i], variables[3 * i + 1], variables[3 * i + 2]
xc = None if 3 * i + 3 >= nvars else variables[3 * i + 3]
# x_i
clauses.append(Or(LE(x, Real(alpha)), LE(Real(1 - alpha), x)))
# x_i -- y_i
clauses.append(
Or(LE(y, Plus(x, Real(-alpha))), LE(Plus(x, Real(alpha)), y)))
# x_i -- z_i
clauses.append(Or(LE(Real(1 - alpha), x), LE(Real(1 - alpha), z)))
clauses.append(Or(LE(x, Real(alpha)), LE(z, Real(alpha))))
# z_i -- y_i
clauses.append(LE(z, y))
# x_i -- x_i+1
if xc:
clauses.append(Or(LE(x, Real(alpha)), LE(Real(1 - alpha), xc)))
clauses.append(Or(LE(Real(1 - alpha), x), LE(xc, Real(alpha))))
pot_yz = Ite(LE(z, y), Times([z, y, Real(100)]), Real(1))
pot_xy = Ite(LE(y, Plus(x, Real(-alpha))),
Times(Real(100), Plus(x, y)), Real(1))
potentials.append(pot_xy)
potentials.append(pot_yz)
if remain == 1:
x = variables[3 * n_tris]
clauses.append(Or(LE(x, Real(alpha)), LE(Real(1 - alpha), x)))
if remain == 2:
x, y = variables[3 * n_tris], variables[nvars - 1]
# x_n
clauses.append(Or(LE(x, Real(alpha)), LE(Real(1 - alpha), x)))
# x -- y
clauses.append(
Or(LE(y, Plus(x, Real(-alpha))), LE(Plus(x, Real(alpha)), y)))
potentials.append(
Ite(LE(y, Plus(x, Real(-alpha))), Times(Real(100), Plus(x, y)),
Real(1)))
domain = Domain.make(
[], # no booleans
[x.symbol_name() for x in variables],
[(0, 1) for _ in range(len(variables))])
support = And(lbounds + ubounds + clauses)
weight = Times(potentials) if len(potentials) > 1 else potentials[0]
return Density(domain, support, weight, []), alpha
def renormalize_node(self, support):
if self.is_leaf():
domA = [
var.symbol_name() for var in self.bounds
if var.symbol_type() == BOOL
]
domX = []
bs = []
for var, b in self.bounds.items():
if var.symbol_type() == REAL:
domX.append(var.symbol_name())
bs.append(tuple(b))
domain = Domain.make(domA, domX, bs)
intersection = And(support, self.bounds_to_SMT())
engine = PredicateAbstractionEngine(domain, intersection, Real(1))
intervol = engine.compute_volume()
if not intervol > 0:
raise ModelException("Non-positive leaf intersection volume")
if self.volume != intervol:
self.renorm_const = self.volume / intervol
else:
self.pos.renormalize_node(support)
self.neg.renormalize_node(support)
def make_from_graph(graph):
n = graph.vcount()
domain = Domain.make([], [f"x{i}" for i in range(n)], real_bounds=(-1, 1))
X = domain.get_symbols()
support = smt.And(*((X[e.source] + 1 <= X[e.target]) | (X[e.target] <= X[e.source] - 1)
for e in graph.es))
return Density(domain, support & domain.get_bounds(), smt.Real(1))
def ex1_b2_r2():
domain = Domain.make(["a", "b"], ["x", "y"], [(0, 1), (0, 1)])
a, b, x, y = domain.get_symbols(domain.variables)
support = (a | b) & (~a | ~b) & (x >= 0.0) & (x <= y) & (y <= 1.0)
weight = Ite(a, Real(0.6), Real(0.4)) * Ite(b, Real(0.8), Real(0.2))\
* (Ite(x >= Real(0.5), Real(0.5) * x + Real(0.1) * y, Real(0.1) * x + Real(0.7) * y))
return Density(domain, support, weight, [x <= y / 2])
def univariate(n):
domain = Domain.make([], ["x{}".format(i) for i in range(n)], real_bounds=(-2, 2))
x_vars = domain.get_symbols()
support = smt.And(*[x > 0.5 for x in x_vars])
weight = smt.Times(*[smt.Ite((x > -1) & (x < 1), smt.Ite(x < 0, x + smt.Real(1), -x + smt.Real(1)), smt.Real(0))
for x in x_vars])
return FileDensity(domain, support, weight)
def simple_univariate_problem():
variables = ["x"]
var_types = {"x": REAL}
var_domains = {"x": (0, 1)}
theory = LE(Symbol("x", REAL), Real(0.6))
return Domain(variables, var_types, var_domains), theory, "one_test"
def test_plot_boolean_or():
nested_string = "(| (var bool a) (var bool b))"
domain = Domain.make(["a", "b"], ["x", "y"], [(0, 1), (0, 1)])
formula = nested_to_smt(nested_string)
with TemporaryFile(suffix=".png") as filename:
plot_formula(filename, domain, formula)
image = Image.open(filename)
assert image.getpixel((900, 900)) == image.getpixel((300, 900))
def integrate(self, domain: Domain, expression: int, variables=None) -> int:
result = expression
integrator = ResolveIntegrator(
self.pool, reduce_strategy=self.reduce_strategy[1],
)
for v in variables or domain.variables:
result = integrator.integrate(result, domain.get_symbol(v))
return result
def test_boolean():
domain = Domain.make(["a", "b", "c"])
sample_count = 10
data = sample.uniform(domain, sample_count)
assert len(data) == sample_count
for i in range(sample_count):
for j in range(3):
assert data[i, j] == 0 or data[i, j] == 1
def test_real():
domain = Domain.make([], ["x", "y"], [(-1, 1), (2, 10)])
sample_count = 10
data = sample.uniform(domain, sample_count)
assert len(data) == sample_count
for i in range(sample_count):
assert -1 <= data[i, 0] <= 1
assert 2 <= data[i, 1] <= 10
def test_sampling_max_samples():
domain = Domain.make([], ["x", "y"], real_bounds=(0, 1))
x, y = domain.get_symbols()
support = smt.FALSE()
try:
positive(10, domain, support, max_samples=100000)
assert False
except SamplingError:
assert True
def _test_plot_data():
domain = Domain.make(["a"], ["x", "y"], [(0, 1), (0, 1)])
a, x, y = domain.get_symbols(["a", "x", "y"])
formula = a | (~a & (x <= y))
data = uniform(domain, 100)
labels = evaluate(domain, formula, data)
mpl.use('Agg')
plot_data(None, domain, (data, labels))
assert True
def ex_jonathan_smaller():
domain = Domain.make(["f0", "d0"], ["r0"], [(10, 45)])
f0, d0 = domain.get_bool_symbols()
r0, = domain.get_real_symbols()
support = ((f0 & ~(r0 <= 35) & ~d0) |
(f0 & (r0 <= 35) & ~d0)) & domain.get_bounds()
weight_function = Real(0.00000001) * r0 * r0 * r0
return Density(domain, support, weight_function, queries=[d0])
def test_sampling_stacking():
domain = Domain.make([], ["x", "y"], real_bounds=(0, 1))
x, y = domain.get_symbols()
support = (x <= y)
try:
positive(20, domain, support, sample_count=10, max_samples=10000)
assert True
except ValueError:
assert False
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 integrate(self, domain, convex_bounds: List[LinearInequality],
polynomial: Polynomial):
formula = smt.And(*[i.to_smt() for i in convex_bounds])
if self.bounding_box > 0:
if self.bounding_box == 1:
a_matrix = numpy.zeros(
(len(convex_bounds), len(domain.real_vars)))
b_matrix = numpy.zeros((len(convex_bounds), ))
for i, bound in enumerate(convex_bounds):
for j in range(len(domain.real_vars)):
a_matrix[i, j] = bound.a(domain.real_vars[j])
b_matrix[i] = bound.b()
lb_ub_bounds = {}
c = numpy.zeros((len(domain.real_vars), ))
for j in range(len(domain.real_vars)):
c[j] = 1
# noinspection PyTypeChecker
lb = scipy.optimize.linprog(c, a_matrix, b_matrix).x[j]
# noinspection PyTypeChecker
ub = scipy.optimize.linprog(-c, a_matrix, b_matrix).x[j]
c[j] = 0
lb_ub_bounds[domain.real_vars[j]] = (lb, ub)
elif self.bounding_box == 2:
samples = uniform(domain,
self.sample_count,
rand_gen=self.rand_gen)
labels = evaluate(domain, formula, samples)
samples = samples[labels == 1]
try:
samples.sort(axis=0)
std = abs(samples[0:-1, :] - samples[1:, :]).std(axis=0)
lbs = samples[0, :] - std
ubs = samples[-1, :] + std
except ValueError:
return 0
lb_ub_bounds = {
domain.variables[j]: (lbs[j], ubs[j])
for j in range(len(domain.variables))
}
else:
raise ValueError("Illegal bounding box value {}".format(
self.bounding_box))
domain = Domain(domain.variables, domain.var_types, lb_ub_bounds)
engine = RejectionEngine(domain,
formula,
polynomial.to_smt(),
self.sample_count,
seed=self.seed)
result = engine.compute_volume()
if self.bounding_box:
result = result
return result
def negative_samples_example(background_knowledge):
domain = Domain.make(["a", "b"], ["x", "y"], [(0, 1), (0, 1)])
a, b, x, y = domain.get_symbols(domain.variables)
formula = (a | b) & (~a | ~b) & (x <= y) & domain.get_bounds()
background_knowledge = (a | b) & (~a
| ~b) if background_knowledge else None
thresholds = {"x": 0.1, "y": 0.2}
data = uniform(domain, 10000)
labels = evaluate(domain, formula, data)
data = data[labels == 1]
labels = labels[labels == 1]
original_sample_count = len(labels)
start_time = time.time()
data, labels = OneClassStrategy.add_negatives(domain, data, labels,
thresholds, 100,
background_knowledge)
print("Created {} negative examples".format(
len(labels) - original_sample_count))
directory = "test_output{}bg_sampled{}{}".format(
os.path.sep, os.path.sep, time.strftime("%Y-%m-%d %Hh%Mm%Ss"))
def learn_inc(_data, _labels, _i, _k, _h):
strategy = OneClassStrategy(RandomViolationsStrategy(10),
thresholds,
background_knowledge=background_knowledge)
learner = KCnfSmtLearner(_k, _h, strategy, "mvn")
initial_indices = LearnOptions.initial_random(20)(list(
range(len(_data))))
learner.add_observer(
PlottingObserver(domain, directory,
"run_{}_{}_{}".format(_i, _k,
_h), domain.real_vars[0],
domain.real_vars[1], None, False))
return learner.learn(domain, _data, _labels, initial_indices)
(new_data, new_labels,
learned_formula), k, h = learn_bottom_up(data, labels, learn_inc, 1, 1, 1,
1, None, None)
if background_knowledge:
learned_formula = learned_formula & background_knowledge
duration = time.time() - start_time
print("{}".format(smt_to_nested(learned_formula)))
print("Learned CNF(k={}, h={}) formula {}".format(
k, h, pretty_print(learned_formula)))
print("Data-set grew from {} to {} entries".format(len(labels),
len(new_labels)))
print("Learning took {:.2f}s".format(duration))
test_data, labels = OneClassStrategy.add_negatives(domain, data, labels,
thresholds, 1000,
background_knowledge)
assert all(evaluate(domain, learned_formula, test_data) == labels)
def test_latte_backend():
print(xadd_installed)
x, y = [Symbol(n, REAL) for n in "xy"]
inequalities = [LinearInequality.from_smt(f) for f in [(x >= 0), (x <= y), (y <= 1)]]
polynomial = Polynomial.from_smt((x*2/3 + 13/15) * (y*1/8 + x))
domain = Domain.make([], ["x", "y"], [(0, 1), (0, 1)])
result = LatteIntegrator().integrate(domain, inequalities, polynomial)
xadd_result = EngineConvexIntegrationBackend(PyXaddEngine()).integrate(domain, inequalities, polynomial)
print(result, xadd_result)
assert result == pytest.approx(xadd_result, rel=0.001)
def dual(n):
n = 2*n
domain = Domain.make([], ["x{}".format(i) for i in range(n)], real_bounds=(0, 1))
x_vars = domain.get_symbols()
terms = [x_vars[2 * i] <= x_vars[2 * i + 1] for i in range(int(n / 2))]
disjunction = smt.Or(*terms)
for i in range(len(terms)):
for j in range(i + 1, len(terms)):
disjunction &= ~terms[i] | ~terms[j]
return FileDensity(domain, disjunction & domain.get_bounds(), smt.Real(1))
