def prove_rnn_max_property(self, img_patch, rnn_out_idx, max_value, n): ''' prove property on the rnn :param rnn_out_idx: one of rnn output idx :param max_value: max value for the output :param n: number of iterations :return: ''' if img_patch is None: img_patch = np.array([0.1, 0.2, 0.3, 0.4] * 28) # 112 # img_patch = np.array([0.2] * 112) # img_patch = np.load('1.pt') img_patch = img_patch[:MAX_SIZE] self.set_network_description(img_patch, n) property_eq = MarabouCore.Equation(MarabouCore.Equation.GE) property_eq.addAddend(1, self.rnn_output_idxs[rnn_out_idx]) property_eq.setScalar(max_value) rnn_start_idxs = [i - 3 for i in self.rnn_output_idxs] algorithm = IterateAlphasSGD(self.rnn_initial_values, rnn_start_idxs, self.rnn_output_idxs) return prove_multidim_property(self.network, rnn_start_idxs, self.rnn_output_idxs, [property_eq], algorithm)
def prove_adv_property(self, img_patch, out_idx_max, out_idx_compare, n): ''' prove property on the rnn :param img_path: The input img for the network :param out_idx_max: which index in the output should be maximum :param n: number of iterations :return: ''' if img_patch is None: # img_patch = np.array([0.1, 0.2, 0.3, 0.4] * 28) # 112 img_patch = np.array([0.2] * 112) img_patch = img_patch[:MAX_SIZE] properties = [] self.set_network_description(img_patch, n) assert len(self.out_idx) > out_idx_max property_eq = MarabouCore.Equation(MarabouCore.Equation.GE) property_eq.addAddend(1, self.out_idx[out_idx_max]) property_eq.addAddend(-1, out_idx_compare) property_eq.setScalar(small) properties.append(property_eq) rnn_start_idxs = [i - 3 for i in self.rnn_output_idxs] return prove_multidim_property(self.network, rnn_start_idxs, self.rnn_output_idxs, self.rnn_initial_values, properties)
def query(xlim: List[Tuple[float, float]], P: Optional[List[Predicate]], Q: List[Predicate], h5_file_path: str, algorithm_ptr, n_iterations=10, steps_num=5000): ''' :param xlim: list of tuples each tuple is (lower_bound, upper_bound), input bounds :param P: predicates on the input (linear constraints), besides the bounds on the input (xlim) :param Q: conditions on the output (linear constraints), not negated :param h5_file_path: path to keras model which we will check on :param n_iterations: number of iterations to run :return: True / False, and queries_stats ''' rnn_model = RnnMarabouModel(h5_file_path, n_iterations) rnn_model.set_input_bounds(xlim) add_predicates(rnn_model, P, n_iterations) start_initial_alg = timer() algorithm = algorithm_ptr(rnn_model, xlim) end_initial_alg = timer() Q_negate = [] for q in Q: Q_negate.append(negate_equation(q.get_equation(rnn_model))) res, queries_stats = prove_multidim_property(rnn_model, Q_negate, algorithm, debug=1, return_queries_stats=True, number_of_steps=steps_num) if queries_stats: step_times = queries_stats['step_times']['raw'] step_times.insert(0, end_initial_alg - start_initial_alg) queries_stats['step_times'] = {'avg': np.mean(step_times), 'median': np.median(step_times), 'raw': step_times} queries_stats['step_queries'] = len(step_times) return res, queries_stats, algorithm.alpha_history
def test_auto_positive_sum_positive_iterateSGD(): num_iterations = 10 xlim = (-1, 1) ylim = (0, num_iterations + 1.1) network, rnn_start_idxs, invariant_equation, property_eqs, initial_values = define_positive_sum_network_no_invariant( xlim, ylim, num_iterations) rnn_output_idxs = [i + 3 for i in rnn_start_idxs] algorithm = IterateAlphasSGD(initial_values, rnn_start_idxs, rnn_output_idxs) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, property_eqs, algorithm)
def adversarial_query(x: list, radius: float, y_idx_max: int, other_idx: int, h5_file_path: str, algorithm_ptr, n_iterations=10, steps_num=5000): ''' Query marabou with adversarial query :param x: base_vector (input vector that we want to find a ball around it) :param radius: determines the limit of the inputs around the base_vector :param y_idx_max: max index in the output layer :param other_idx: which index to compare max idx :param h5_file_path: path to keras model which we will check on :param algorithm_ptr: TODO :param n_iterations: number of iterations to run :return: True / False, and queries_stats ''' if y_idx_max is None or other_idx is None: y_idx_max, other_idx = get_out_idx(x, n_iterations, h5_file_path) if y_idx_max == other_idx or y_idx_max is None or other_idx is None: # This means all the enteris in the out vector are equal... return False, None, None xlim = calc_min_max_by_radius(x, radius) rnn_model = RnnMarabouModel(h5_file_path, n_iterations) rnn_model.set_input_bounds(xlim) # output[y_idx_max] >= output[0] <-> output[y_idx_max] - output[0] >= 0, before feeding marabou we negate this adv_eq = MarabouCore.Equation(MarabouCore.Equation.GE) adv_eq.addAddend(-1, rnn_model.output_idx[other_idx]) adv_eq.addAddend(1, rnn_model.output_idx[y_idx_max]) adv_eq.setScalar(0) time_eq = MarabouCore.Equation() time_eq.addAddend(1, rnn_model.get_start_end_idxs(0)[0][0]) time_eq.setScalar(n_iterations) start_initial_alg = timer() algorithm = algorithm_ptr(rnn_model, xlim) end_initial_alg = timer() # rnn_model.network.dump() res, queries_stats = prove_multidim_property(rnn_model, [negate_equation(adv_eq), time_eq], algorithm, debug=1, return_queries_stats=True, number_of_steps=steps_num) if queries_stats: step_times = queries_stats['step_times']['raw'] step_times.insert(0, end_initial_alg - start_initial_alg) queries_stats['step_times'] = {'avg': np.mean(step_times), 'median': np.median(step_times), 'raw': step_times} queries_stats['step_queries'] = len(step_times) if 'invariant_queries' in queries_stats and 'property_queries' in queries_stats and \ queries_stats['property_queries'] != queries_stats['invariant_queries']: print("What happened?\n", x) return res, queries_stats, algorithm.alpha_history
def auto_positive_sum_positive_SMTbase(): num_iterations = 10 xlim = (-1, 1) ylim = (0, num_iterations + 1.1) network, rnn_start_idxs, invariant_equation, property_eqs, initial_values = define_positive_sum_network_no_invariant( xlim, ylim, num_iterations) rnn_output_idxs = [i + 3 for i in rnn_start_idxs] algorithm = SmtAlphaSearch(initial_values, rnn_start_idxs, rnn_output_idxs, np.array([[1]]), np.array([[1]]), [0], [xlim[0]], [xlim[1]], num_iterations) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, property_eqs, algorithm)
def test_adversarial_robustness_two_inputs_two_hidden_SGDAlgorithm(): ''' This example has 2 input nodes and two RNN cells ''' num_iterations = 10 xlim = [(0, 1), (1, 2)] network, rnn_output_idxs, initial_values, property_eq = \ define_adversarial_robustness_two_input_nodes_two_hidden(xlim, num_iterations) network.dump() rnn_start_idxs = [i - 3 for i in rnn_output_idxs] algorithm = IterateAlphasSGD(initial_values, rnn_start_idxs, rnn_output_idxs) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, property_eq, algorithm)
def prove_out_max_property(self, out_idx, max_value): ''' :param out_idx: index in the 10 vector output :param max_value: maximum value for that index :return: True / False ''' raise NotImplementedError self._calc_output_initial_values(img_patch, n) property_eq = MarabouCore.Equation(MarabouCore.Equation.GE) property_eq.addAddend(w_out[0], out_idx) property_eq.setScalar(max_value) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, self.output_initial_values, [property_eq])
def test_auto_adversarial_robustness_two_inputs_SGDAlgorithm(): ''' This example has 2 input nodes and two RNN cells ''' from RNN.MarabouRNNMultiDim import prove_multidim_property from rnn_algorithms.IterateAlphasSGD import IterateAlphasSGD num_iterations = 10 xlim = [(0, 1), (1, 2)] network, rnn_start_idxs, property_eq, initial_values, *_ = define_adversarial_robustness_two_input_nodes(xlim, num_iterations) rnn_invariant_type = [MarabouCore.Equation.GE, MarabouCore.Equation.LE] # network.dump() rnn_output_idxs = [i + 3 for i in rnn_start_idxs] algorithm = IterateAlphasSGD(initial_values, rnn_start_idxs, rnn_output_idxs) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, property_eq, algorithm)
rnn_output_idxs = add_rnn_cells(network, w_in, w_h, b_h, n) rnn_start_idxs = [i - 3 for i in rnn_output_idxs] w_out = np.array([1, 0]) property_eq = MarabouCore.Equation(MarabouCore.Equation.GE) property_eq.addAddend(w_out[0], rnn_output_idxs[0]) property_eq.setScalar(23.1) # draw_r_values(*calc_rnn_values(x_max, w_in, w_h, n)) w_in = np.array([w_in_0, w_in_1]) r_min, r_max = calc_min_max_values(x_min, x_max, w_in, np.zeros(w_in.shape)) initial_values = [r_min, r_max] y, rs = get_max_value([x_min, x_max], w_in, w_h, b_h, w_out, 0, n) print("network max value: {}\nrecurrent max values: {}".format(y, rs)) assert prove_multidim_property(network, rnn_start_idxs, rnn_output_idxs, initial_values, [property_eq]) print('property proved') # # # print("rnn_start_idxs:", rnn_start_idxs) # output_idx = add_output_equations(network, rnn_output_idxs, np.array([w_out_0, w_out_1]).T, np.array([0.3])) # # network.dump() # # print("output idx:", output_idx) # # # Let's verify that the output node is less then 100, after 10 iterations # n = 10 # property_eq = MarabouCore.Equation(MarabouCore.Equation.LE) # property_eq.addAddend(1, output_idx[0]) # property_eq.setScalar(100) # # # network, rnn_start_idxs, rnn_invariant_type, initial_values, n_iterations, # # property_equations, min_alphas = None, max_alphas = None, rnn_dependent = None