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'))