def _simple_run(self, n_check_invariant):
self.setup_controller_obj()
self.setup_overt_dyn_obj()
tr = TFControlledTransitionRelation(dynamics_obj=self.overt_dyn_obj,
controller_obj=self.controller_obj,
turn_max_to_relu=True)
init_set = dict(zip(self.state_vars, self.init_range))
ts = TransitionSystem(states=tr.states,
initial_set=init_set,
transition_relation=tr)
for c in ts.transition_relation.constraints:
assert (not isinstance(c, MaxConstraint))
#solver = MarabouWrapper(n_worker=self.ncore)
solver = GurobiPyWrapper()
prop = self.setup_property()
algo = BMC(ts=ts, prop=prop, solver=solver)
return algo.check_invariant_until(n_check_invariant)
def run_one_timestep(self):
itr = 0
self.setup_property(no_initial_expansion=True)
while itr < self.max_itr:
#self.history.append("trying, init_set: " + str(self.init_set) + "prop_set: "+str(self.prop_set))
self.update_transition_system()
itr += 1
prop = ConstraintProperty(self.prop_list)
algo = BMC(ts=self.ts, prop=prop, solver=self.solver)
for x, x_int in self.prop_set.items():
print(" ", x, ": ", x_int)
result, value, stats = algo.check_invariant_until(
self.ncheck_invariant)
result = result.name
if result == "UNSAT":
return
else:
self.widen_property(dict(list(value)))
if itr == self.max_itr:
raise (ValueError("max iteration reached."))
p1.scalar = 0.3
prop_list.append(p1)
p2 = Constraint(ConstraintType('LESS'))
p2.monomials = [Monomial(1, states[0])]
p2.scalar = 1.15
prop_list.append(p2)
# p3 = Constraint(ConstraintType('GREATER'))
# p3.monomials = [Monomial(1, states[1])]
# p3.scalar = -1.1
# prop_list.append(p3)
# #
# p4 = Constraint(ConstraintType('LESS'))
# p4.monomials = [Monomial(1, states[1])]
# p4.scalar = 1.49
# prop_list.append(p4)
prop = ConstraintProperty(prop_list, [states[0]])
# algo
ncheck_invariant = 4
algo = BMC(ts=ts, prop=prop, solver=solver)
result = algo.check_invariant_until(ncheck_invariant)
# random runs to give intuition to MC result
n_simulation = 10000
simulate(single_pendulum, prop, model, init_set, states, n_simulation,
ncheck_invariant, dt)
#simulate_single_pend(prop, n_simulation, ncheck_invariant, model, dt, init_set, states)
def test_marabou_interface(alpha,
prop_desc,
n_invar,
with_relu=False,
with_max=False):
# create controller object, this is just a place holder. I will modify the object later.
model = load_model(
"../OverApprox/models/single_pend_nn_controller_lqr_data.h5")
controller = KerasController(keras_model=model)
# rewrite to make a simple controller that is always equal to alpha*x
controller.control_outputs = [['c']]
controller.state_inputs = [['xc']]
fake_constraint = []
if with_relu:
alpha_times_x = 'var1'
monomial_list = [
Monomial(alpha, controller.state_inputs[0][0]),
Monomial(-1, alpha_times_x)
]
fake_constraint.append(
Constraint(ConstraintType('EQUALITY'), monomial_list, 0.0))
relu_constraint = [
ReluConstraint(varin=alpha_times_x,
varout=controller.control_outputs[0][0])
]
controller.constraints = relu_constraint + fake_constraint
controller.relus = relu_constraint
elif with_max:
alpha_times_x = 'var1'
monomial_list = [
Monomial(alpha, controller.state_inputs[0][0]),
Monomial(-1, alpha_times_x)
]
fake_constraint.append(
Constraint(ConstraintType('EQUALITY'), monomial_list, 0.0))
max_second_arg = 'var2'
fake_constraint.append(
Constraint(ConstraintType('EQUALITY'),
[Monomial(1, max_second_arg)], -1 / 2))
max_constraint = [
MaxConstraint(varsin=[alpha_times_x, max_second_arg],
varout=controller.control_outputs[0][0])
]
controller.constraints = max_constraint + fake_constraint
controller.relus = []
else:
monomial_list = [
Monomial(-1, controller.control_outputs[0][0]),
Monomial(alpha, controller.state_inputs[0][0])
]
fake_constraint = [
Constraint(ConstraintType('EQUALITY'), monomial_list, 0.0)
]
controller.constraints = fake_constraint
controller.relus = []
# create overt dynamics objects. this is just a place holder. I will modify the object later.
overt_obj = OvertConstraint(
"../OverApprox/models/single_pend_acceleration_overt.h5")
# rewrite to make a simple controller that is always equal to x
overt_obj.control_vars = [['cd']]
overt_obj.state_vars = [['x']]
overt_obj.output_vars = [['dx']]
monomial_list2 = [
Monomial(1, overt_obj.control_vars[0][0]),
Monomial(-1, overt_obj.output_vars[0][0])
]
fake_constraint2 = [
Constraint(ConstraintType('EQUALITY'), monomial_list2, 0.5)
]
overt_obj.constraints = fake_constraint2
simple_dynamics = Dynamics(np.array(['x']), np.array(['cd']))
next_states = simple_dynamics.next_states.reshape(1, )
# x_next = x + dt*dx
dt = 1
c1 = Constraint(ConstraintType('EQUALITY'))
c1.monomials = [
Monomial(1, overt_obj.state_vars[0][0]),
Monomial(dt, overt_obj.output_vars[0][0]),
Monomial(-1, next_states[0])
]
simple_dynamics.constraints = [c1] + overt_obj.constraints
print(len(simple_dynamics.constraints))
print(len(controller.constraints))
# create transition relation using controller and dynamics
tr = TFControlledTransitionRelation(dynamics_obj=simple_dynamics,
controller_obj=controller)
# initial set
init_set = {overt_obj.state_vars[0][0]: (0., 1.)}
# build the transition system as an (S, I(S), TR) tuple
ts = TransitionSystem(states=tr.states,
initial_set=init_set,
transition_relation=tr)
# property x< 0.105, x' < 0.2
p = Constraint(ConstraintType(prop_desc["type"]))
p.monomials = [Monomial(1, overt_obj.state_vars[0][0])]
p.scalar = prop_desc["scalar"] #
prop = ConstraintProperty([p], [overt_obj.state_vars[0][0]])
# solver
solver = MarabouWrapper()
algo = BMC(ts=ts, prop=prop, solver=solver)
result, vals, stats = algo.check_invariant_until(n_invar)
return result.name
# initial set
init_set = {"x": (1.1,2), "y": (-1,1)}
# build the transition system as an (S, I(S), TR) tuple
ts = TransitionSystem(states=tr.states, initial_set=init_set, transition_relation=tr)
# solver
solver = MarabouWrapper()
# property
p = Constraint(ConstraintType('GREATER'))
# x > c (complement will be x <= c)
p.monomials = [Monomial(1, "x")]
p.scalar = 1. # 0 #
prop = ConstraintProperty([p], ["x"])
# algo
algo = BMC(ts = ts, prop = prop, solver=solver)
algo.check_invariant_until(3)
# random runs to give intuition to MC result
for i in range(10):
x = np.random.rand()*(2 - 1.1) + 1.1
print("x@0=", x)
y = np.random.rand()*(1 - -1) + -1
for j in range(3):
state = np.array([x,y]).flatten().reshape(-1,1)
u = np.maximum(0, W2@(np.maximum(0,W1@state + b1)) + b2)
#x' = relu(x + u)
x = max(0, x + u.flatten()[0])
print("x@",j+1,"=", x)
# do MC! ######################################################################################
from dynamical_systems.dynamical_systems import f1
from transition_systems import OVERTDynamics, TFControlledOVERTTransitionRelation, MyTransitionSystem, TFController
from MC_interface import BMC
from marabou_interface import MarabouWrapper
my_dynamics = OVERTDynamics(f1, np.array([["x"], ["theta"]], dtype=object),
np.array([["u"]], dtype=object))
init_set = {"x": (0, 5), "theta": (-np.pi / 4, np.pi / 4)}
controller = TFController(tf_sess=sess,
inputNames=[x.op.name],
outputName=output.op.name)
tr = TFControlledOVERTTransitionRelation(dynamics_obj=my_dynamics,
controller_obj=controller)
transition_system = MyTransitionSystem(states=my_dynamics.states,
initial_set=init_set,
transition_relation=tr)
solver = MarabouWrapper()
property_file = "my_prop1.txt" # property defined over the states
algo = BMC(ts=transition_system, prop_file=property_file, solver=solver)
import pdb
pdb.set_trace()
algo.check_invariant_until(3)
# for debug
# imp.reload(MC_interface)
# from MC_interface import OVERTDynamics, TFControlledOVERTTransitionRelation, MyTransitionSystem, BMC, TFController