def export(path: str) -> None: torch_path = f"{path}.pth" onnx_path = f"{path}.onnx" tensorflow_path = f"{path}.pb" tensorflowjs_path = path model = LeNet5(10) model.load_state_dict(torch.load(torch_path)) model = model.eval().cpu() torch.onnx.export( model, torch.zeros((1, 1, 28, 28)).float(), onnx_path, input_names=["img"], output_names=["pred"], do_constant_folding=True, export_params=True, opset_version=10, verbose=True, ) model = onnx.load(onnx_path) prepare(model).export_graph(tensorflow_path) convert_tf_saved_model(tensorflow_path, tensorflowjs_path)
def test(): onnx_model = onnx.load("resnet50.onnx") torch.random.manual_seed(0) input = torch.rand(1, 3, 224, 224).numpy() output = prepare(onnx_model).run(input) print("output:", output) tf_rep = prepare(onnx_model) print("tf_rep.inputs:", tf_rep.inputs) print("tf_rep.outputs:", tf_rep.outputs) tf_rep.export_graph("./resnet50.graph")
def convert(input_ops_dict, output_ops, input_model, output_model): '''Convert keras h5 to tensorflow pb Args: input_ops_dict: input ops dict including names and shapes output_ops: output op names input_model: input keras h5 model name output_model: output pb model name ''' onnx_name = ".tmp.onnx" pb_name = ".tmp.pb" # keras --> onnx --> pb --> onnx --> pb # keras --> onnx model = tf.keras.models.load_model(input_model) onnx_model = keras2onnx.convert_keras(model, model.name, target_opset=8) keras2onnx.save_model(onnx_model, onnx_name) # onnx --> tf onnx_model = onnx.load(onnx_name) tf_rep = prepare(onnx_model, input_shape_dict=input_ops_dict) tf_rep.export_graph(pb_name) # tf --> onnx (fold constants) inputs = input_ops_dict.keys() inputs = [i + ":0" for i in inputs] outputs = output_ops graph_def, inputs, outputs = tf_loader.from_graphdef( pb_name, inputs, outputs) with tf.Graph().as_default() as tf_graph: tf.import_graph_def(graph_def, name="") g = tf2onnx.tfonnx.process_tf_graph(tf_graph, opset=8, input_names=inputs, output_names=outputs) onnx_graph = optimizer.optimize_graph(g) model_proto = onnx_graph.make_model("converted from %s" % pb_name) utils.save_protobuf(onnx_name, model_proto) # onnx --> tf onnx_model = onnx.load(onnx_name) tf_rep = prepare(onnx_model, input_shape_dict=input_ops_dict) tf_rep.export_graph(output_model) # remove tmp files if os.path.exists(onnx_name): os.remove(onnx_name) if os.path.exists(pb_name): os.remove(pb_name)
def detect_face(image): global cnt image = cv2.resize(image,(640,480)) img = image.copy() img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_mean = np.array([127, 127, 127]) img = (img - img_mean) / 128 img = np.transpose(img, [2, 0, 1]) img = np.expand_dims(img, axis=0) img = img.astype(np.float32) onnx_model = onnx.load('Copy of ultra_light_640.onnx') predictor = prepare(onnx_model) ort_session = ort.InferenceSession('Copy of ultra_light_640.onnx') input_name = ort_session.get_inputs()[0].name confidences, boxes = ort_session.run(None, {input_name: img}) h,w,_ = image.shape boxes, labels, probs = predict(w, h, confidences, boxes, 0.7) cnt = 0 for i in range(boxes.shape[0]): if probs[cnt]>0.99: box = boxes[i, :] x1, y1, x2, y2 = box crop_image = image[y1:y2,x1:x2] if crop_image.shape[0]<=0 or crop_image.shape[1]<=0 or len(crop_image)==0: continue coords.append((x1, y1, x2, y2)) image_list.append(crop_image) cnt = cnt + 1 return coords, image_list
def conv_test(): conv1_weights = tf.Variable(np.load("conv1w.npy").astype(np.float32)) conv1_biases = tf.Variable(np.load("conv1b.npy").astype(np.float32)) d = tf.placeholder(tf.float32, shape=[1, 28, 28, 1]) sess = tf.Session() sess.run(tf.initialize_all_variables()) conv = tf.nn.conv2d(d, conv1_weights, strides=[1, 1, 1, 1], padding='SAME') tf_model = tf.nn.bias_add(conv, conv1_biases) model = onnx.load("test_conv.onnx") tf_rep = prepare(model) npmodel = Testmodel(1) img = np.load("img.npy") for ele in img: data = ele.reshape([1, 28, 28, 1]) tf_result = sess.run(tf_model, feed_dict={d: data}) tf_result = np.array(tf_result) npresult = npmodel.infer(data) data = ele.reshape([1, 1, 28, 28]) output = np.array(tf_rep.run(data)) output = output[0] print(output.shape) output = np.swapaxes(output, 2, 3) output = np.swapaxes(output, 1, 3) print(output[0][0][1]) print(tf_result[0][0][1]) print(npresult[0][0][1]) break
def test_auto_cast(self): node_def = helper.make_node("Equal", ["a", "b"], ["Y"]) graph_def = helper.make_graph( [node_def], name="test_auto_cast", inputs=[ helper.make_tensor_value_info("a", TensorProto.UINT64, [None, None]), helper.make_tensor_value_info("b", TensorProto.UINT64, [None, None]) ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.BOOL, [None, None]) ]) tf_rep = prepare(helper.make_model(graph_def), auto_cast=True) # random inputs with shape [5, 5] a = np.random.randint(low=0, high=10, size=(5, 5)).astype(np.uint64) b = np.random.randint(low=0, high=10, size=(5, 5)).astype(np.uint64) Y_ref = np.equal(a, b) # check the output from converter API against numpy's output output = tf_rep.run({"a": a, "b": b}) np.testing.assert_almost_equal(output.Y, Y_ref)
def helper_test_onnx_tf(model, input_shape: List[int], tmpdir: str): """Ensure the model outputs do not change under onnx-tf transformation.""" # run the model and cache the outputs test_spec: List[Tuple[np.ndarray, np.ndarray]] = [] for i in range(5): rnd_input = np.random.rand(*input_shape).astype(np.float32) spec_output = model(torch.from_numpy(rnd_input)) test_spec.append((rnd_input, spec_output)) # convert model to tensorflow graph onnx_model_path = str(Path(tmpdir) / "model.onnx") torch.onnx.export(model, torch.from_numpy(test_spec[0][0]), onnx_model_path) original_onnx_model = onnx.load(onnx_model_path) onnx_model = onnx.optimizer.optimize(original_onnx_model, passes=[ 'eliminate_identity', 'eliminate_nop_transpose', 'fuse_consecutive_transposes', 'fuse_consecutive_squeezes', 'fuse_add_bias_into_conv', ]) onnx_model = onnx.utils.polish_model(onnx_model) tf.reset_default_graph() tf_rep = prepare(onnx_model) # test tf graph for (rnd_input, spec_output) in test_spec: tf_output = tf_rep.run({"0": rnd_input}) assert tf_output._0 == approx(spec_output.data.numpy(), abs=1e-4, rel=1e-4)
def gen_pb(): from trades.models.wideresnet import WideResNet import torch import onnx from onnx_tf.backend import prepare device = torch.device("cuda") model = WideResNet().to(device) model.load_state_dict(torch.load('./model_cifar_wrn.pt')) model.eval() dummy_input = torch.from_numpy(np.zeros( (64, 3, 32, 32), )).float().to(device) dummy_output = model(dummy_input) torch.onnx.export(model, dummy_input, './model_cifar_wrn.onnx', input_names=['input'], output_names=['output']) model_onnx = onnx.load('./model_cifar_wrn.onnx') tf_rep = prepare(model_onnx) # Print out tensors and placeholders in model (helpful during inference in TensorFlow) print(tf_rep.tensor_dict) # Export model as .pb file tf_rep.export_graph('./model_cifar_wrn.pb')
def __init__(self, sess): # Preparing predictor onnx_model = onnx.load('ultra_light_640.onnx') self.predictor = prepare(onnx_model) self.ort_session = ort.InferenceSession('ultra_light_640.onnx') self.input_name = self.ort_session.get_inputs()[0].name logging.info("ultralight model loaded") self.shape_predictor = dlib.shape_predictor( 'shape_predictor_5_face_landmarks.dat') self.f_a = face_utils.facealigner.FaceAligner(self.shape_predictor, desiredFaceWidth=112, desiredLeftEye=(0.3, 0.3)) self.threshold = 0.63 with open("embeddings.pkl", "rb") as f: self.saved_embeds, self.names = pickle.load(f) logging.info("Loaded saved embeddings") self.sess = sess self.saver = tf.train.import_meta_graph('mfn.ckpt.meta') self.saver.restore(self.sess, 'mfn.ckpt') logging.info("tensorflow session restored") # Setting up tensors g = tf.get_default_graph() self.images_placeholder = g.get_tensor_by_name('input:0') self.embeddings = g.get_tensor_by_name('embeddings:0') self.phase_train_placeholder = g.get_tensor_by_name('phase_train:0') self.embedding_size = self.embeddings.get_shape()[1]
def convert(infile, outdir, **kwargs): """Convert pb. Args: infile: Input path. outdir: Output path. **kwargs: Other args for converting. Returns: None. """ logging_level = kwargs.get("logging_level", "INFO") ext_data_dir = kwargs.get("extdatadir") common.logger.setLevel(logging_level) common.logger.handlers[0].setLevel(logging_level) common.logger.info("Start converting onnx pb to tf saved model") # load external data if the file directory is provided if ext_data_dir: onnx_model = onnx.load(infile, load_external_data=False) load_external_data_for_model(onnx_model, ext_data_dir) else: onnx_model = onnx.load(infile) tf_rep = backend.prepare(onnx_model, **kwargs) tf_rep.export_graph(outdir) common.logger.info("Converting completes successfully.")
def _export_via_onnx(model, inputs): from ipdb import set_trace set_trace() def _check_val(module): assert not module.training model.apply(_check_val) # Export the model to ONNX with torch.no_grad(): with io.BytesIO() as f: torch.onnx.export( model, inputs, f, # verbose=True, # NOTE: uncomment this for debugging export_params=True, ) onnx_model = onnx.load_from_string(f.getvalue()) # torch.onnx.export(model, # model being run # inputs, # model input (or a tuple for multiple inputs) # "reid_test.onnx", # where to save the model (can be a file or file-like object) # export_params=True, # store the trained parameter weights inside the model file # opset_version=10, # the ONNX version to export the model to # do_constant_folding=True, # whether to execute constant folding for optimization # input_names=['input'], # the model's input names # output_names=['output'], # the model's output names # dynamic_axes={'input': {0: 'batch_size'}, # variable lenght axes # 'output': {0: 'batch_size'}}) # ) # Apply ONNX's Optimization # all_passes = optimizer.get_available_passes() # passes = ["fuse_bn_into_conv"] # assert all(p in all_passes for p in passes) # onnx_model = optimizer.optimize(onnx_model, passes) # Convert ONNX Model to Tensorflow Model tf_rep = prepare(onnx_model, strict=False) # Import the ONNX model to Tensorflow print(tf_rep.inputs) # Input nodes to the model print('-----') print(tf_rep.outputs) # Output nodes from the model print('-----') # print(tf_rep.tensor_dict) # All nodes in the model # """ # install onnx-tensorflow from github,and tf_rep = prepare(onnx_model, strict=False) # Reference https://github.com/onnx/onnx-tensorflow/issues/167 # tf_rep = prepare(onnx_model) # whthout strict=False leads to KeyError: 'pyfunc_0' # debug, here using the same input to check onnx and tf. # output_onnx_tf = tf_rep.run(to_numpy(img)) # print('output_onnx_tf = {}'.format(output_onnx_tf)) # onnx --> tf.graph.pb # tf_pb_path = 'reid_tf_graph.pb' # tf_rep.export_graph(tf_pb_path) return tf_rep
def test_gru_savedmodel(self): input_size = 3 hidden_size = 3 weight_scale = 0.1 custom_bias = 0.1 number_of_gates = 3 node_def = helper.make_node('GRU', inputs=['X', 'W', 'R', 'B'], outputs=['Y', 'Y_h'], hidden_size=hidden_size) graph_def = helper.make_graph( [node_def], name="gru_test", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 3, 3]), helper.make_tensor_value_info("W", TensorProto.FLOAT, [1, 9, 3]), helper.make_tensor_value_info("R", TensorProto.FLOAT, [1, 9, 3]), helper.make_tensor_value_info("B", TensorProto.FLOAT, [1, 18]) ], outputs=[ helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 1, 3, 3]), helper.make_tensor_value_info("Y_h", TensorProto.FLOAT, [1, 3, 3]) ]) tf_rep = prepare(helper.make_model(graph_def)) model_path = "gru_savedmodel" tf_rep.export_graph(model_path) # initializing Inputs X = np.array([[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]]).astype(np.float32) W = weight_scale * np.ones( (1, number_of_gates * hidden_size, input_size)).astype(np.float32) R = weight_scale * np.ones( (1, number_of_gates * hidden_size, hidden_size)).astype(np.float32) W_B = custom_bias * np.ones( (1, number_of_gates * hidden_size)).astype(np.float32) R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32) B = np.concatenate((W_B, R_B), axis=1) # use the ONNX reference implementation to get the expected output gru = GRU_Helper(X=X, W=W, R=R, B=B) _, Y_ref = gru.step() # load the savedmodel from file system m = tf.saved_model.load(model_path) # run the model tf_output = m(X=X, W=W, R=R, B=B) np.testing.assert_almost_equal(tf_output[1], Y_ref) # clean up saved model folder shutil.rmtree(model_path)
def pytorch2tensorflow(): model_path = "model_path" # step 1 init pytorch cuda_ = 'cuda:{}'.format(0) device = torch.device(cuda_ if torch.cuda.is_available() else 'cpu') pytorch_model_path = os.path.join(model_path, "siamese.ckpt") model = ResNet18SiameseNetwork() model_params = torch.load(pytorch_model_path) siamese_state_dict = {} for k, v in model_params.items(): siamese_state_dict[k.replace('module.', '')] = v model.load_state_dict(siamese_state_dict) model.eval() # step 2 pytorch to onnx dummy_input = Variable(torch.randn(1, 3, HEIGHT, WIDTH)) # nchw onnx_model_path = os.path.join(model_path, "siamese.onnx") torch.onnx.export(model, dummy_input, onnx_model_path, verbose=True) pytorch_feature = test_pytorch(model, test_img) onnx_feature = test_onnx(onnx_model_path, test_img) compare_feature(pytorch_feature, onnx_feature) print("pytorch to onnx ok!") # # step 3 onnx --> tf pb onnx_model = onnx.load(onnx_model_path) tf_pb_path = os.path.join(model_path, "siamese.pb") print("1") tf_rep = prepare(onnx_model, strict=False) print("2") tf_rep.export_graph(tf_pb_path) #tf_feature = test_tensorflow(tf_pb_path) #compare_feature(pytorch_feature, tf_feature) print("onnx to tensorflow ok!")
def convert_to_tensorflow(pytorch_model_path, model_class): """ Converts a trained pytorch model to a tensorflow model using ONNX :param pytorch_model_path: Path to pytorch model """ # Setup filenames fileroot = os.path.basename(pytorch_model_path).split('.')[0] dirname = os.path.dirname(pytorch_model_path) onnx_path = '{}.onnx'.format(os.path.join(dirname, fileroot)) tf_path = '{}.pb'.format(os.path.join(dirname, fileroot)) print("Saving onnx file to {}".format(onnx_path)) print("Saving onnx file to {}".format(tf_path)) print("Loading trained model...") trained_model = model_class() trained_model.load_state_dict(torch.load(pytorch_model_path)) # Export the trained model to ONNX print("Exporting model to ONNX...") input_size = trained_model.get_input_size() dummy_input = Variable(torch.randn(input_size)) torch.onnx.export(trained_model, dummy_input, onnx_path) # Create Tensorflow Representation print("Creating tensorflow representation...") onnx_model = onnx.load(onnx_path) tf_rep = prepare(onnx_model) print("Saving tensorflow graph...") tf_rep.export_graph(tf_path)
def test_if_with_sequence(self): # S = [a] # if cond is True # S = [a,b] # else # S = [a,c] a = np.random.randn(2, 1, 2).astype(np.float32) b = np.random.randn(1, 1, 2).astype(np.float32) c = np.random.randn(3, 1, 2).astype(np.float32) seq_construct_node = helper.make_node('SequenceConstruct', ['a'], ['S']) seq_insert_node1 = helper.make_node('SequenceInsert', ['S', 'b'], ['Sb']) seq_insert_node2 = helper.make_node('SequenceInsert', ['S', 'c'], ['Sc']) a_in = helper.make_tensor_value_info('a', onnx.TensorProto.FLOAT, [2, 1, 2]) b_in = helper.make_tensor_value_info('b', onnx.TensorProto.FLOAT, [1, 1, 2]) c_in = helper.make_tensor_value_info('c', onnx.TensorProto.FLOAT, [3, 1, 2]) cond_in = helper.make_tensor_value_info('cond', TensorProto.BOOL, []) s_in = helper.make_sequence_value_info('S', TensorProto.FLOAT, [None, None, None, None]) sb_out = helper.make_sequence_value_info('Sb', TensorProto.FLOAT, [None, None, None, None]) sc_out = helper.make_sequence_value_info('Sc', TensorProto.FLOAT, [None, None, None, None]) s_final_out = helper.make_sequence_value_info('S_final', TensorProto.FLOAT, [None, None, None, None]) then_graph = helper.make_graph(nodes=[seq_insert_node1], name="then_graph", inputs=[s_in, b_in], outputs=[sb_out]) else_graph = helper.make_graph(nodes=[seq_insert_node2], name="else_graph", inputs=[s_in, c_in], outputs=[sc_out]) if_node = helper.make_node('If', ['cond'], ['S_final'], then_branch=then_graph, else_branch=else_graph) graph_def = helper.make_graph(nodes=[seq_construct_node, if_node], name='test_if', inputs=[a_in, b_in, c_in, cond_in], outputs=[s_final_out]) tf_rep = prepare(helper.make_model(graph_def)) output = tf_rep.run({ 'a': a, 'b': b, 'c': c, 'cond': np.array(True, dtype=np.bool) }) np.testing.assert_almost_equal(output['S_final'].values[:2], a) np.testing.assert_almost_equal(output['S_final'].values[2:], b) output = tf_rep.run({ 'a': a, 'b': b, 'c': c, 'cond': np.array(False, dtype=np.bool) }) np.testing.assert_almost_equal(output['S_final'].values[:2], a) np.testing.assert_almost_equal(output['S_final'].values[2:], c)
def do_test_expected(self): tf_op = test_data[1] output_name = test_data[2] inputs = test_data[3] attrs = test_data[4] # Now construct input feed dict # keyed by input name onnx_feed_dict = {} # keyed by placeholder op tf_feed_dict = {} tf_param_list = [] for idx, input_tensor in enumerate(inputs): if type(input_tensor) is np.ndarray: placeholder = tf.placeholder(input_tensor.dtype, shape=input_tensor.shape, name="in_" + str(idx)) onnx_feed_dict["in_" + str(idx)] = input_tensor tf_feed_dict[placeholder] = input_tensor tf_param_list.append(placeholder) else: tf_param_list.append(input_tensor) test_op = tf_op(*tf_param_list, **attrs) tf_graph = test_op.graph.as_graph_def(add_shapes=True) # Construct onnx graph, run with backend. output_node = get_node_by_name(tf_graph.node, output_name) onnx_graph = convert_graph(tf_graph, output_node) backend_rep = prepare(helper.make_model(onnx_graph)) backend_output = backend_rep.run(onnx_feed_dict)[output_name] with tf.Session() as sess: tf_output = sess.run(test_op, tf_feed_dict) tf.reset_default_graph() np.testing.assert_allclose(backend_output, tf_output)
def export_tf_proto(onnx_file, meta_file): """ Exports the ONNX model to a Tensorflow Proto file. The exported file will have a .meta extension. :param onnx_file: string, Path to the .onnx model file :param meta_file: string, Path to the exported Tensorflow .meta file :return: tuple, input and output tensor dictionaries. Dictionaries have a {tensor_name: TF_Tensor_op} structure. """ model = onnx.load(onnx_file) # Convert the ONNX model to a Tensorflow graph tf_rep = prepare(model, strict=False) global pb_output pb_output = tf_rep.run(input_np) output_keys = tf_rep.outputs input_keys = tf_rep.inputs tf_dict = tf_rep.tensor_dict input_tensor_names = {key: tf_dict[key] for key in input_keys} output_tensor_names = {key: tf_dict[key] for key in output_keys} tf_rep.export_graph(meta_file) log.info("Exported Tensorflow proto file to {}".format(meta_file)) return input_tensor_names, output_tensor_names
def test_initializer(self): X = np.array([[1, 2], [3, 4]]).astype(np.float32) Y = np.array([[1, 2], [3, 4]]).astype(np.float32) weight = np.array([[1, 0], [0, 1]]) graph_def = helper.make_graph( [ helper.make_node("Add", ["X", "Y"], ["Z0"]), helper.make_node("Cast", ["Z0"], ["Z"], to="float"), helper.make_node("Mul", ["Z", "weight"], ["W"]), helper.make_node("Tanh", ["W"], ["W1"]), helper.make_node("Sigmoid", ["W1"], ["W2"]) ], name="test_initializer", inputs=[ helper.make_tensor_value_info("X", TensorProto.FLOAT, (2, 2)), helper.make_tensor_value_info("Y", TensorProto.FLOAT, (2, 2)), helper.make_tensor_value_info("weight", TensorProto.FLOAT, (2, 2)), ], outputs=[ helper.make_tensor_value_info("W2", TensorProto.FLOAT, (2, 2)) ], initializer=[ helper.make_tensor("weight", TensorProto.FLOAT, [2, 2], weight.flatten().astype(float)) ]) def sigmoid(x): return 1 / (1 + np.exp(-x)) W_ref = sigmoid(np.tanh((X + Y) * weight)) tf_rep = prepare(helper.make_model(graph_def)) output = tf_rep.run({"X": X, "Y": Y}) np.testing.assert_almost_equal(output["W2"], W_ref)
def OnnxEmit(original_framework, architecture_name, architecture_path, weight_path, image_path): from mmdnn.conversion.onnx.onnx_emitter import OnnxEmitter original_framework = checkfrozen(original_framework) # IR to code converted_file = original_framework + '_onnx_' + architecture_name + "_converted" converted_file = converted_file.replace('.', '_') emitter = OnnxEmitter(architecture_path, weight_path) emitter.run(converted_file + '.py', None, 'test') del emitter del OnnxEmitter # import converted model from onnx_tf.backend import prepare model_converted = __import__(converted_file).KitModel(weight_path) tf_rep = prepare(model_converted) func = TestKit.preprocess_func[original_framework][architecture_name] img = func(image_path) input_data = np.expand_dims(img, 0) predict = tf_rep.run(input_data)[0] del prepare del model_converted del tf_rep os.remove(converted_file + '.py') return predict
def Main(queue, msg_queue): #region init # load the model, create runtime session & get input variable name onnx_path = 'model/ultra_light_640.onnx' onnx_model = onnx.load(onnx_path) predictor = prepare(onnx_model) ort_session = ort.InferenceSession(onnx_path) input_name = ort_session.get_inputs()[0].name import dlib shape_predictor = dlib.shape_predictor( 'model/shape_predictor_68_face__landmarks.dat') fa = face_utils.facealigner.FaceAligner(shape_predictor, desiredFaceWidth=112, desiredLeftEye=(0.3, 0.3)) #endregion try: with tf.Graph().as_default(): with tf.Session() as sess: ip.In_Program_M(sess, ort_session, input_name, fa, queue, msg_queue) except Exception as e: print(e)
def initialize(self, model, model_as_file): if not HAS_TF_ONNX: raise Exception( 'Tensorflow(version 1.13.1 or above), Onnx(version 1.5.0) and Onnx_tf(version 1.3.0) libraries are not installed. Install Tensorflow using "conda install tensorflow-gpu=1.13.1". Install onnx and onnx_tf using "pip install onnx onnx_tf".' ) from arcgis.learn.models import SingleShotDetector if model_as_file: with open(model, 'r') as f: self.json_info = json.load(f) else: self.json_info = json.loads(model) model_path = self.json_info['ModelFile'] anc_grids = self.json_info['Grids'] anc_zooms = self.json_info['Zooms'] anc_ratios = self.json_info['Ratios'] self.batch_size = self.json_info['BatchSize'] if model_as_file and not os.path.isabs(model_path): model_path = os.path.abspath( os.path.join(os.path.dirname(model), model_path)) model_onnx = onnx.load(model_path) self.tf_rep_graph = prepare(model_onnx) self._anchors, self._grid_sizes = _create_anchors( anc_grids, anc_zooms, anc_ratios)
def main(): """Main function""" # Option parser parser = argparse.ArgumentParser() parser.add_argument("--onnx", action="store", help="input onnx model") parser.add_argument("--imgs", action="store", help="Comma separated list of images") args = parser.parse_args() # Convert onnx to TF model = onnx.load(args.onnx) print("preparing model") tf_rep = prepare(model) # load mnist using PyTorch test_loader = torch.utils.data.DataLoader( datasets.MNIST('../data', train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=1000, shuffle=True) # run the model output = tf_rep.run(np.asarray(test_loader, dtype=np.float32)[np.newaxis, np.newaxis, :, :])
def covert_to_tensorflow_and_save(pytorch_model, path, args): if args['dataset'] == 'mnist': dummy_input = torch.randn(1, 1, 28, 28) elif args['dataset'] == 'cifar10': dummy_input = torch.randn(1, 1, 32, 32) elif args['dataset'] == 'physionet': dummy_input = torch.randn(1, 1, 12000) elif args['dataset'] == 'shhs': dummy_input = torch.randn(1, 1, 15000) if args['device'] == torch.device('cuda'): dummy_input = dummy_input.cuda() torch.onnx.export(pytorch_model, dummy_input, path + '.onnx') onnx_model = onnx.load(path + '.onnx') tf_model = prepare(onnx_model) tf_model.export_graph(path + '.pb') # graph_def_file = args['chkpnt_dir'] + "tf_model.pb" # input_arrays = ['0'] # output_arrays = ['LogSoftmax'] # converter = tf.lite.TFLiteConverter.from_frozen_graph(graph_def_file, input_arrays, output_arrays) # tflite_model = converter.convert() return tf_model
def _convert_to_tf(self): onnx_output_dir = './onnx_output/model.onnx' if not os.path.exists('./onnx_output/'): os.makedirs('./onnx_output/') if not os.path.exists('./tf_model/'): os.makedirs('./tf_model/') dummy_input = torch.rand(self.__input_dims) # Export the onnx representation to the onnx_output_dir torch.onnx.export(self.__new_model, dummy_input, onnx_output_dir, input_names=['input'], output_names=['output']) # Load ONNX representation and convert to TensorFlow format model_onnx = onnx.load(onnx_output_dir) tf_rep = prepare(model_onnx, strict=False) # Get the output and input tensors from the tf_rep with tf.Session() as sess: sess.graph.as_default() tf.import_graph_def(tf_rep.graph.as_graph_def(), name='') self.input_tensor = sess.graph.get_tensor_by_name( tf_rep.tensor_dict['input'].name) self.output_tensor = sess.graph.get_tensor_by_name( tf_rep.tensor_dict['output'].name) self.tf_graph = sess.graph
def validate_onnx_model(platform, device_type, model_file, input_file, mace_out_file, input_names, input_shapes, input_data_formats, output_names, output_shapes, output_data_formats, validation_threshold, input_data_types, backend, log_file): import onnx if backend == "tensorflow": from onnx_tf.backend import prepare print("valivate on onnx tensorflow backend.") elif backend == "caffe2" or backend == "pytorch": from caffe2.python.onnx.backend import prepare print("valivate on onnx caffe2 backend.") else: common.MaceLogger.error( VALIDATION_MODULE, "onnx backend framwork '" + backend + "' is invalid.") if not os.path.isfile(model_file): common.MaceLogger.error( VALIDATION_MODULE, "Input graph file '" + model_file + "' does not exist!") model = onnx.load(model_file) input_dict = {} for i in range(len(input_names)): input_value = load_data(common.formatted_file_name(input_file, input_names[i]), input_data_types[i]) input_value = input_value.reshape(input_shapes[i]) if input_data_formats[i] == common.DataFormat.NHWC and \ len(input_shapes[i]) == 4: input_value = input_value.transpose((0, 3, 1, 2)) input_dict[input_names[i]] = input_value onnx_outputs = [] for i in range(len(output_names)): out_shape = output_shapes[i][:] if output_data_formats[i] == common.DataFormat.NHWC and\ len(out_shape) == 4: out_shape[1], out_shape[2], out_shape[3] = \ out_shape[3], out_shape[1], out_shape[2] onnx_outputs.append( onnx.helper.make_tensor_value_info(output_names[i], onnx.TensorProto.FLOAT, out_shape)) model.graph.output.extend(onnx_outputs) rep = prepare(model) output_values = rep.run(input_dict) for i in range(len(output_names)): out_name = output_names[i] value = output_values[out_name].flatten() output_file_name = common.formatted_file_name(mace_out_file, output_names[i]) mace_out_value = load_data(output_file_name) if output_data_formats[i] == common.DataFormat.NHWC and \ len(output_shapes[i]) == 4: mace_out_value = mace_out_value.reshape(output_shapes[i]) \ .transpose((0, 3, 1, 2)) compare_output(platform, device_type, output_names[i], mace_out_value, value, validation_threshold, log_file)
def onnx2tf(): # https://ichi.pro/ko/pytorchleul-tensorflow-litelo-byeonhwanhaneun-naui-yeojeong-14449401839341 # https://github.com/onnx/onnx-tensorflow TF_PATH = "C:/Users/mmclab1/Desktop/fakecheck/tf_model_adv" ONNX_PATH = "C:/Users/mmclab1/Desktop/fakecheck/onnx_model_adv.onnx" onnx_model = onnx.load(ONNX_PATH) # load onnx model print('success loading onnx file') tf_rep = prepare(onnx_model) # creating TensorflowRep object ''' Process finished with exit code -1073741819 (0xC0000005) Error code 0xc0000005 means "access violation" -> Please check your MPI code for memory/stack/heap access issues. And make sure any array access has valid index. ==> 해결) 읽어들인 학습된 가중치(.pt)는 torch.save(model.state_dict(), PATH) 모델 객체의 state_dict가 저장되었기 때문. model.load_state_dict(best_model_wts) 전체모델 저장으로 바꿔서 수행 ==> jupyter lab이나 colab으로 실행 ''' print('success creating tensorflowRep') tf_rep.export_graph(TF_PATH) # export the model print('success converting onnx to tensorflow')
def convert_to_tf(onnx_path: str, tf_path: str): if not os.path.exists(tf_path): os.makedirs(tf_path) onnx_model = onnx.load(onnx_path) #onnx.checker.check_model(onnx_model) # Checks signature tf_rep = prepare(onnx_model) # Prepare TF representation tf_rep.export_graph(tf_path) return tf_path
def build_model_from_onnx(self, filename): model = onnx.load(filename) tf_rep = prepare(model) print(tf_rep.predict_net.tensor_dict[ tf_rep.predict_net.external_input[0]].name) print(tf_rep.predict_net.tensor_dict[ tf_rep.predict_net.external_output[0]].name) return tf_rep
def main(): onnx_path = "models/yolo_v3.onnx" pb_path = "models/yolo_v3.pb" onnx_model = onnx.load(onnx_path) tf_exp = prepare(onnx_model, device='CPU') print(tf_exp.tensor_dict) tf_exp.export_graph(pb_path)
def torch2tf(model): dummy_input = torch.randn(1, 1, 48, 48) torch.onnx.export(model, dummy_input, './models/onnx_model.onnx') onnx_model = onnx.load('./models/onnx_model.onnx') tf_model = prepare(onnx_model) tf_model.export_graph('./models/model_simple.pb')
def convert_onnx_to_model(onnx_input_path): """Reimplementation of the TensorFlow-onnx official tutorial convert the onnx file to specific: model Parameters ----------- onnx_input_path : string the path where you save the onnx file. References ----------- - `onnx-tf exporting tutorial <https://github.com/onnx/tutorials/blob/master/tutorials/OnnxTensorflowExport.ipynb>`__ """ model = onnx.load(onnx_input_path) tf_rep = prepare(model) # Image Path img = np.load("./assets/image.npz") output = tf_rep.run(img.reshape([1, 784])) print("The digit is classified as ", np.argmax(output))
# can be expressed using Gemm alternatively node = oh.make_node('MatMul', ["pdf","cdfmat"], ["cdf"]) # ArgMax(Clip(cdf + (1 - rand), max=1)) # node_rand_sub = oh.make_node('Sub', ["one","r"], ["rr"]) add_node = oh.make_node('Add', ["cdf", "r"], ["temp"], broadcast=1) clip_node = oh.make_node('Clip', ["temp"], ["cdf_clipped"], min=0.0, max=1.0) topk_node = oh.make_node('ArgMax', ["cdf_clipped"], ["chosen_action"], axis=1, keepdims=0) graph = oh.make_graph([one, one_int, pdf_temp, pdf_temp_2, max_score, normalized_scores, # top_action_1, # top_action_2, # one_hot_top_action_int, one_hot_top_action_float, one_hot_top_action, exploit_prob, exploit_top_action, pdf, # node_rand_sub, node, node_rand, add_node, clip_node, topk_node], 'compute_graph', input_tensors, output_tensors, initializer_tensors) model = oh.make_model(graph, producer_name='explore') f = open("model1.onnx", "wb") f.write(model.SerializeToString()) f.close() tf_model = onnx.load('model1.onnx') tf_rep = prepare(tf_model) sample = tf_rep.run(np.asarray([[.3,.3,.4]])) print(sample)