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