def _turn_max_to_relu(self):
new_constraints = []
for c in self.constraints:
if isinstance(c, MaxConstraint):
# varnew1 - varin1 + varin2 = 0
# varnew2 = relu(varnew1)
# varout - varnew2 - varin2 = 0
var1in = c.var1in
var2in = c.var2in
varout = c.varout
varnew1 = getNewVariable("max2relu")
varnew2 = getNewVariable("max2relu")
cnew1 = Constraint("EQUALITY")
cnew1.monomials = [
Monomial(1.0, varnew1),
Monomial(-1.0, var1in),
Monomial(1.0, var2in)
]
cnew2 = ReluConstraint(varin=varnew1, varout=varnew2)
cnew3 = Constraint("EQUALITY")
cnew3.monomials = [
Monomial(1.0, varout),
Monomial(-1.0, var2in),
Monomial(-1.0, varnew2)
]
new_constraints.extend([cnew1, cnew2, cnew3])
else:
new_constraints.append(c)
self.constraints = new_constraints
def constraint_variable_to_interval(variable, LB, UB):
p1 = Constraint(ConstraintType('GREATER'))
p1.monomials = [Monomial(1, variable)]
p1.scalar = LB # 0 #
#
p2 = Constraint(ConstraintType('LESS'))
p2.monomials = [Monomial(1, variable)]
p2.scalar = UB
return [p1, p2]
def setup_euler_constraint(self, dx_vec, dt):
for x, dx, next_x in zip(self.states.reshape(-1), dx_vec,
self.next_states.reshape(-1)):
c = Constraint(ConstraintType('EQUALITY'))
c.monomials = [
Monomial(1, x),
Monomial(dt, dx),
Monomial(-1, next_x)
]
self.euler_constraints.append(c)
def setup_euler_constraints(self):
for x, dx, next_x in zip(self.states.reshape(-1), self.dx,
self.next_states.reshape(-1)):
# next_x = x + dx*dt
c = Constraint(ConstraintType('EQUALITY'))
c.monomials = [
Monomial(1, x),
Monomial(self.dt, dx),
Monomial(-1, next_x)
]
self.constraints.append(c)
# initial set
x1_init_set = (0.5, 1)
x2_init_set = (-0.5, 0.5)
init_set = {states[0]: x1_init_set, states[1]: x2_init_set}
# 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 = GurobiPyWrapper() #MarabouWrapper()
prop_list = []
p1 = Constraint(ConstraintType('GREATER'))
p1.monomials = [Monomial(1, states[0])]
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])]
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
output = tf.nn.relu(tf.matmul(W1,x) + b1)
W2 = np.random.rand(1,2)
b2 = np.random.rand(1,1)
output = tf.nn.relu(tf.matmul(W2,output) + b2)
sess.run(tf.global_variables_initializer()) # actually sets Variable values to values specified
# smoosh all tf.Variables to tf.Constants, put into new graph
new_graph = smoosh_to_const(sess, output.op.name)
# create controller object with network
controller = TFController(tf_sess=tf.Session(graph=new_graph), inputNames=[x.op.name], outputName=output.op.name)
# create a super simple plant directly using constraint objects
dynamics = Dynamics(states=np.array([["x"], ["y"]]), controls=["u"], fun=np.sin)
# x' = relu(x + u) -> x + u - z = 0 , x' = relu(z)
c1 = Constraint(ConstraintType('EQUALITY'))
c1.monomials = [Monomial(1, "x"), Monomial(1,"u"), Monomial(-1,"z")]
c3 = ReluConstraint(varin="z", varout="x'")
# y' = y -> y - y' = 0
c2 = Constraint(ConstraintType('EQUALITY'))
c2.monomials = [Monomial(1,"y"), Monomial(-1, "y'")]
dynamics.constraints = [c1,c2,c3]
# create transition relation using controller and dynamics
tr = TFControlledTransitionRelation(dynamics_obj=dynamics,
controller_obj=controller)
# 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)
controls = overt_obj_1.control_vars
acceleration_1 = overt_obj_1.output_vars[0]
acceleration_2 = overt_obj_2.output_vars[0]
double_pendulum_dynamics = Dynamics(np.array(states).reshape(-1, 1), np.array(controls).reshape(-1, 1))
next_states = double_pendulum_dynamics.next_states.reshape(4,)
print(states, controls, acceleration_1, acceleration_2, next_states)
dt = 0.01
# x1_next = x1 + dt*u1
c1 = Constraint(ConstraintType('EQUALITY'))
c1.monomials = [Monomial(1, theta1), Monomial(dt, theta1d), Monomial(-1, next_states[0])]
print(c1.monomials)
# x2_next = x2 + dt*u2
c2 = Constraint(ConstraintType('EQUALITY'))
c2.monomials = [Monomial(1, theta2), Monomial(dt, theta2d), Monomial(-1, next_states[1])]
print(c2.monomials)
# u1_next = u1 + dt*a1
c3 = Constraint(ConstraintType('EQUALITY'))
c3.monomials = [Monomial(1, theta1d), Monomial(dt, acceleration_1), Monomial(-1, next_states[2])]
print(c3.monomials)
# u2_next = u2 + dt*a2
c4 = Constraint(ConstraintType('EQUALITY'))