def get_n_hidden_units(layer): assert (layer != None) if keras_layer.is_dense(layer): weights = layer.get_weights( ) # the second are biases, the first are weights between two layers kernel = weights[0] hidden_units_pre_layer = kernel.shape[0] hidden_units_curr_layer = kernel.shape[1] return hidden_units_pre_layer, hidden_units_curr_layer else: return None
def get_dense_layers(model): dense_layers = [] indexes = [] if isinstance(model, Sequential): for idx, layer in enumerate(model.layers): if keras_layer.is_dense(layer): dense_layers.append(layer) indexes.append(idx) return zip(dense_layers, indexes)
def generate_weights(model: Sequential): output = "" for idx, current_layer in enumerate(model.layers): print("") print(f"layer {current_layer.name}") print(f"layer {current_layer}") weights = current_layer.get_weights() # the second are biases, the first are weights between two layers if keras_layer.is_dense(current_layer): kernel = weights[0] biases = weights[1] print(f"#neuron in pre layer = {kernel.shape[0]}") print(f"#neuron in next layer = {kernel.shape[1]}") print(f"#neuron in bias = {len(biases)}") for i in range(kernel.shape[0]): for j in range(kernel.shape[1]): output += f"double {weight(idx - 1, i, j)} = {kernel[i][j]};" output += "\n" return output
def generate_weights(model: Sequential): output = "" for idx, current_layer in enumerate(model.layers): print("") print(f"layer {current_layer.name}") print(f"layer {current_layer}") weights = current_layer.get_weights() # the second are biases, the first are weights between two layers if keras_layer.is_dense(current_layer): kernel = weights[0] output += f"double[][] {current_layer.name}_kernel = new double[{kernel.shape[0]}][{kernel.shape[1]}];\n" for i in range(kernel.shape[0]): for j in range(kernel.shape[1]): output += f"{current_layer.name}_kernel[{i}][{j}] = {kernel[i][j]}; " output += "\n" biases = weights[1] # shape = #filter output += f"double[] {current_layer.name}_bias = new double[{biases.shape[0]}];\n" for i in range(0, biases.shape[0]): output += f"{current_layer.name}_bias[{i}] = {biases[i]}; " # print(output) elif keras_layer.is_conv2d(current_layer): kernel = weights[0] # shape = (#filter_width, #filter_height, #channel, #filter) output += f"double[][][][] {current_layer.name}_kernel = new double[{kernel.shape[0]}][{kernel.shape[1]}][{kernel.shape[2]}][{kernel.shape[3]}];\n" for i in range(0, kernel.shape[0]): for j in range(0, kernel.shape[1]): for k in range(0, kernel.shape[2]): for h in range(0, kernel.shape[3]): output += f"{current_layer.name}_kernel[{i}][{j}][{k}][{h}] = {kernel[i][j][k][h]}; " output += "\n" biases = weights[1] # shape = #filter output += f"double[] {current_layer.name}_bias = new double[{biases.shape[0]}];\n" for i in range(0, biases.shape[0]): output += f"{current_layer.name}_bias[{i}] = {biases[i]}; " # print(output) return output
def create_constraint_of_propogation_layers(model_object, modified_features, x): assert (isinstance(model_object, abstract_dataset)) smt_constraints = [] model = model_object.get_model() if not keras_model.is_ANN(model): return for current_layer_idx, current_layer in enumerate(model.layers): pre_layer_idx = current_layer_idx - 1 if keras_layer.is_dense(current_layer): smt_constraints.append(f'\n; Dense layer {current_layer.name}') weights = current_layer.get_weights() # the second are biases, the first are weights between two layers kernel = weights[0] biases = weights[1] n_features = kernel.shape[0] hidden_units_curr_layer = kernel.shape[1] for current_pos in range(hidden_units_curr_layer): var = f'l{current_layer_idx}_{current_pos}' smt_constraint = '' for feature_idx in range(n_features): if current_layer_idx == 0: # 0: the first layer behind the input layer if feature_idx in modified_features: previous_var = f'(/ feature_{feature_idx} 255)' # symbolic value else: previous_var = f'{x[feature_idx]}' # real value else: previous_var = f'l{pre_layer_idx}_{feature_idx}' weight = kernel[feature_idx][current_pos] # weight = weight / NORMALIZATION_FACTOR # rather than normalizing feature input if feature_idx == 0: smt_constraint = f'(* {previous_var} {weight:.25f}) ' else: smt_constraint = f'(+ {smt_constraint} (* {previous_var} {weight:.25f})) ' smt_constraint = f'(+ {smt_constraint} {biases[current_pos]:.25f}) ' smt_constraint = f'(assert(= {var} {smt_constraint}))' smt_constraints.append(smt_constraint) elif keras_activation.is_relu(current_layer): units = keras_layer.get_number_of_units(model, current_layer_idx) smt_constraints.append(f'\n; is relu layer') for unit_idx in range(units): ''' constraint type 2 v = u>0?x:0 ''' prelayer_idx = current_layer_idx - 1 smt_constraint = f'(= l{current_layer_idx}_{unit_idx} (ite (>= l{prelayer_idx}_{unit_idx} 0) l{prelayer_idx}_{unit_idx} 0))' smt_constraint = f'(assert{smt_constraint})' smt_constraints.append(smt_constraint) # elif keras_layer.is_dense(current_layer): # pre_layer_idx = current_layer_idx - 1 # pre_layer = model.layers[pre_layer_idx] # # weights = current_layer.get_weights() # the second are biases, the first are weights between two layers # kernel = weights[0] # biases = weights[1] # hidden_units_pre_layer = kernel.shape[0] # hidden_units_curr_layer = kernel.shape[1] # # # # # if keras_layer.is_dense(pre_layer): # instance of Dense # # the current layer and the previous layer is dense # for current_pos in range(hidden_units_curr_layer): # # constraints of a hidden unit layer include (1) bias, and (2) weight # var = f'u_{current_layer_idx}_{current_pos}' # # ''' # type constraint 2 # ''' # smt_constraint = f'{var} = ' # for feature_idx in range(hidden_units_pre_layer): # previous_var = f'v_{pre_layer_idx}_{feature_idx}' # weight = kernel[feature_idx][current_pos] # if feature_idx == 0: # smt_constraint = f'(* {previous_var} {weight:.25f}) ' # else: # smt_constraint = f'(+ {smt_constraint} (* {previous_var} {weight:.25f})) ' # # # smt_constraint = f'(+ {smt_constraint} {biases[current_layer_idx]:.25f}) ' # smt_constraint = f'(assert {smt_constraint})' # smt_constraints.append(smt_constraint) # elif keras_layer.is_activation(pre_layer) or keras_layer.is_dropout( # pre_layer): # instance of keras.layers.core.Dense # for current_pos in range(hidden_units_curr_layer): # var = f'u_{current_layer_idx}_{current_pos}' # previous_var = f'v_{current_layer_idx - 1}_{current_pos}' # # smt_constraint = f'(assert(= {var} {previous_var}))' # smt_constraints.append(smt_constraint) # elif keras_layer.is_activation(current_layer): # pre_layer_idx = current_layer_idx - 1 # pre_layer = model.layers[pre_layer_idx] # # smt_constraints.append(f'\n; (output of {pre_layer.name}, input of {current_layer.name})') # # units = keras_layer.get_number_of_units(model, pre_layer_idx) # for unit_idx in range(units): # smt_constraint = f'(assert(= v_{pre_layer_idx}_{unit_idx} u_{current_layer_idx}_{unit_idx}))' # smt_constraints.append(smt_constraint) return smt_constraints
def is_dense_and_activity(layer): assert (layer != None) if keras_layer.is_dense(layer) and keras_activation.is_activation(layer): return True
lines = f.readlines() for line in lines: code += line; # print(generate_weights(model)) ''' generate predict() ''' code += generate_prototype(inputlayer) + "\n" code += "{\n" code += normalize_features(inputlayer) + "\n" for idx, current_layer in enumerate(model.layers): if keras_layer.is_inputlayer(current_layer): continue; elif keras_layer.is_dense(current_layer): code += handle_dense_layer(model.layers[idx], idx, model) code += "\n" elif keras_layer.is_activation(current_layer): if keras_activation.is_relu(current_layer): code += handle_relu_layer(model.layers[idx], idx, model) code += "\n" elif keras_activation.is_softmax(current_layer): code += handle_softmax_layer(model.layers[idx], idx, model) code += "\n" code += print_all_vars(); code += "}\n\n" ''' initialize testpath