def get_node_metadata(model): value_info = {} for val in model.graph.value_info: value_info[val.name] = ( val.type.tensor_type.elem_type, common.proto_val_to_dimension_tuple(val), ) return value_info
def main(): if len(sys.argv) < 3: print("Model file or scaling factor unspecified.", file=sys.stderr) exit(1) file_name = sys.argv[1] scaling_factor = int(sys.argv[2]) file_path = "models/" + file_name model_name = file_name[:-5] # name without the '.onnx' extension model = onnx.load(file_path) graph_def = model.graph # Generating input input_dims = common.proto_val_to_dimension_tuple(model.graph.input[0]) input_array = numpy.random.random(input_dims) # input_array = numpy.ones(input_dims, dtype=float) print("Generated random input of dimension " + str(input_dims)) np.save("debug/" + model_name + "/" + model_name + "_input", input_array) (chunk, cnt) = common.numpy_float_array_to_fixed_point_val_str( input_array, scaling_factor) f = open("debug/" + model_name + "/" + model_name + "_input.inp", "w") f.write(chunk) f.close() model_name_to_val_dict = { init_vals.name: numpy_helper.to_array(init_vals).tolist() for init_vals in model.graph.initializer } preprocess_batch_normalization(graph_def, model_name_to_val_dict) chunk_n = "" cnt_n = 0 for init_vals in model.graph.initializer: (chunk_1, cnt_1) = common.numpy_float_array_to_fixed_point_val_str( np.asarray(model_name_to_val_dict[init_vals.name], dtype=np.float32), scaling_factor, ) chunk_n += chunk_1 cnt_n += cnt_1 f = open("debug/" + model_name + "/" + model_name + "_weights.inp", "w") f.write(chunk_n) f.close() f = open( "debug/" + model_name + "/" + model_name + "_combined_input_weights.inp", "w") f.write(chunk + chunk_n) f.close() print("Total " + str(cnt + cnt_n) + " integers were written in " + model_name + "_combined_input_weights.inp")
def inferShapes(model): if DEBUG: print(model.graph.value_info) for input in model.graph.input: model.graph.value_info.append( make_tensor_value_info( input.name, common.get_data_type(input), common.proto_val_to_dimension_tuple(input), )) for output in model.graph.output: model.graph.value_info.append( make_tensor_value_info( output.name, common.get_data_type(output), common.proto_val_to_dimension_tuple(output), )) if DEBUG: print(model.graph.value_info) for init_vals in model.graph.initializer: model.graph.value_info.append( make_tensor_value_info(init_vals.name, init_vals.data_type, tuple(init_vals.dims))) if DEBUG: print("Shape inference *****************") print(model.graph.value_info) inferred_model = onnx.shape_inference.infer_shapes(model) if DEBUG: print("Printing shape ******************") print(inferred_model.graph.value_info) print("Done ******************") return inferred_model
def __init__(self, node): self.name = node.name if isinstance(node, ValueInfoProto): # input self.shape = list(common.proto_val_to_dimension_tuple(node)) self.data_type = node.type.tensor_type.elem_type # When weights are stripped from the model by the server, # the doc_string field is set to this exact MPC_MODEL_WEIGHTS # magic keyword if node.doc_string == "MPC_MODEL_WEIGHTS": self.party = AST.Party.SERVER else: self.party = AST.Party.CLIENT elif isinstance(node, TensorProto): # initializers self.shape = list(node.dims) self.data_type = node.data_type self.party = AST.Party.SERVER else: assert False, "Unexpected input type"
def main(): if (len(sys.argv) < 3): print("Model file or scaling factor unspecified.", file=sys.stderr) exit(1) file_name = sys.argv[1] scaling_factor = int(sys.argv[2]) file_path = 'models/' + file_name model_name = file_name[:-5] # name without the '.onnx' extension model = onnx.load(file_path) graph_def = model.graph # Generating input input_dims = common.proto_val_to_dimension_tuple(model.graph.input[0]) input_array = numpy.random.random(input_dims) # input_array = numpy.ones(input_dims, dtype=float) print('Generated random input of dimension ' + str(input_dims)) np.save('debug/' + model_name + '/' + model_name + '_input', input_array) (chunk, cnt) = common.numpy_float_array_to_fixed_point_val_str( input_array, scaling_factor) model_name_to_val_dict = { init_vals.name: numpy_helper.to_array(init_vals).tolist() for init_vals in model.graph.initializer } preprocess_batch_normalization(graph_def, model_name_to_val_dict) for init_vals in model.graph.initializer: (chunk_1, cnt_1) = common.numpy_float_array_to_fixed_point_val_str( np.asarray(model_name_to_val_dict[init_vals.name], dtype=np.float32), scaling_factor) chunk += chunk_1 cnt += cnt_1 f = open('debug/' + model_name + '/' + model_name + '_input.h', 'w') f.write(chunk) f.close() print('Total ' + str(cnt) + ' integers were written in ' + model_name + '_input.h')
def main(): # First read the ONNX file if (len(sys.argv) < 2): print("TF python file unspecified.", file=sys.stderr) exit(1) file_name = sys.argv[1] file_path = 'models/' + file_name model_name = file_name[:-5] # name without the '.onnx' extension model = onnx.load(file_path) model = preprocess_for_tf(model) x = np.load('debug/' + model_name + '/' + model_name + '_input.npy') x = x.astype(np.float32) input_name = model.graph.input[0].name output_name = model.graph.output[0].name if (len(sys.argv) > 2): intermediate_layer_value_info = helper.ValueInfoProto() intermediate_layer_value_info_name = 'tf_' + sys.argv[2] intermediate_layer_value_info = helper.make_tensor_value_info( intermediate_layer_value_info_name, TensorProto.FLOAT, []) model.graph.output.extend([intermediate_layer_value_info]) output = prepare(model).run(x) pred = getattr(output, intermediate_layer_value_info_name) np.save('debug/' + model_name + '/' + model_name + '_debug', pred) with open('debug/onnx_debug.txt', 'w') as f: f.write(common.numpy_float_array_to_float_val_str(pred)) print("Saving the onnx runtime intermediate output for " + intermediate_layer_value_info.name) exit() output = prepare(model).run(x) pred = getattr(output, output_name) np.save('debug/' + model_name + '/' + model_name + '_output', pred) with open('debug/onnx_output.txt', 'w') as f: f.write(common.numpy_float_array_to_float_val_str(pred)) output_dims = common.proto_val_to_dimension_tuple(model.graph.output[0]) print("Saving the onnx runtime output of dimension " + str(output_dims))
file_name = sys.argv[1] file_path = 'models/' + file_name model_name = file_name[:-5] # name without the '.onnx' extension model = onnx.load(file_path) sess = onnxruntime.InferenceSession(file_path) x = np.load('debug/' + model_name + '/' + model_name + '_input.npy') x = x.astype(np.float32) input_name = model.graph.input[0].name if (len(sys.argv) > 2): intermediate_layer_value_info = helper.ValueInfoProto() intermediate_layer_value_info.name = sys.argv[2] model.graph.output.extend([intermediate_layer_value_info]) onnx.save(model, file_path + '_1') sess = onnxruntime.InferenceSession(file_path + '_1') pred = sess.run([intermediate_layer_value_info.name], {input_name: x}) np.save('debug/' + model_name + '/' + model_name + '_debug', pred) with open('debug/onnx_debug.txt', 'w') as f: f.write(common.numpy_float_array_to_float_val_str(pred)) print("Saving the onnx runtime intermediate output for " + intermediate_layer_value_info.name) exit() pred = sess.run(None, {input_name: x}) np.save('debug/' + model_name + '/' + model_name + '_output', pred) with open('debug/onnx_output.txt', 'w') as f: f.write(common.numpy_float_array_to_float_val_str(pred)) output_dims = common.proto_val_to_dimension_tuple(model.graph.output[0]) print("Saving the onnx runtime output of dimension " + str(output_dims))
def main(): sys.setrecursionlimit(10000) # First read the ONNX file if (len(sys.argv) < 2): print("TF python file unspecified.", file=sys.stderr) exit(1) file_name = sys.argv[1] file_path = 'models/' + file_name model_name = file_name[:-5] # name without the '.onnx' extension # load the model and extract the graph model = onnx.load(file_path) graph_def = model.graph print(model.graph.value_info) # Before shape inference (model.graph.value_info) should have shapes of all the variables and constants model.graph.value_info.append( make_tensor_value_info( model.graph.input[0].name, TensorProto.FLOAT, common.proto_val_to_dimension_tuple(model.graph.input[0]))) model.graph.value_info.append( make_tensor_value_info( model.graph.output[0].name, TensorProto.FLOAT, common.proto_val_to_dimension_tuple(model.graph.output[0]))) print(model.graph.value_info) for init_vals in model.graph.initializer: model.graph.value_info.append( make_tensor_value_info(init_vals.name, TensorProto.FLOAT, tuple(init_vals.dims))) if (DEBUG): print("Shape inference *****************") print(model.graph.value_info) inferred_model = onnx.shape_inference.infer_shapes(model) if (DEBUG): print("Printing shape ******************") print(inferred_model.graph.value_info) print("Done ******************") # value_info: dictionary of name -> (type, dimension tuple) value_info = {} for val in inferred_model.graph.value_info: value_info[val.name] = (val.type.tensor_type.elem_type, common.proto_val_to_dimension_tuple(val)) # Iterate through the ONNX graph nodes and translate them to SeeDot AST nodes program = None innermost_let_ast_node = None node_name_to_out_var_dict = {} out_var_count = 0 mtdAST = MtdAST() (program, innermost_let_ast_node, out_var_count) = process_input_variables( program, innermost_let_ast_node, node_name_to_out_var_dict, out_var_count, mtdAST, graph_def, value_info) process_onnx_nodes(innermost_let_ast_node, node_name_to_out_var_dict, out_var_count, mtdAST, graph_def, value_info) PrintAST().visit(program) common.write_debug_info(node_name_to_out_var_dict) with open('debug/' + model_name + '/' + model_name + '.pkl', 'wb') as f: pickle.dump(program, f)