def print_specific_output(model_path, input_tensor, output_name, print_tensor=False): model_onnx = load_onnx_model(model_path) num_onnx = select_model_inputs_outputs(model_onnx, output_name) save_onnx_model(num_onnx, "remove_temp.onnx") sess = rt.InferenceSession("remove_temp.onnx") out_tensor = sess.run(None, input_tensor) print("name", output_name, "shape", out_tensor[0].shape) if print_tensor: print(out_tensor[0])
def _modify_model_add_outputs_nodes(self, model_dir): old_onnx_model = onnx.load(self.args.model_path) utils.print_info_log("load model success") for index, node in enumerate(old_onnx_model.graph.node): if not node.name: node.name = node.op_type + "_" + str(index) outputs_name = [ name for name in enumerate_model_node_outputs(old_onnx_model) ] new_onnx_model = select_model_inputs_outputs(old_onnx_model, outputs_name) new_onnx_model_path = os.path.join( model_dir, "new_" + os.path.basename(self.args.model_path)) save_onnx_model(new_onnx_model, new_onnx_model_path) utils.print_info_log("modify model outputs success") return old_onnx_model, new_onnx_model_path
def get_model(self, model): try: import onnxruntime # noqa except ImportError: return None from onnxruntime import InferenceSession session = InferenceSession(save_onnx_model(model)) return lambda X: session.run(None, {"input": X})[0]
def test_onnx_helper_load_save(self): model = make_pipeline(StandardScaler(), Binarizer(threshold=0.5)) X = numpy.array([[0.1, 1.1], [0.2, 2.2]]) model.fit(X) model_onnx = convert_sklearn(model, "binarizer", [("input", FloatTensorType([1, 2]))]) filename = "temp_onnx_helper_load_save.onnx" save_onnx_model(model_onnx, filename) model = load_onnx_model(filename) new_model = select_model_inputs_outputs(model, "variable") assert new_model.graph is not None tr1 = self.get_model(model) tr2 = self.get_model(new_model) X = X.astype(numpy.float32) X1 = tr1(X) X2 = tr2(X) assert X1.shape == (2, 2) assert X2.shape == (2, 2)
def test_onnx_helper_load_save_init(self): model = make_pipeline(Binarizer(), OneHotEncoder(sparse=False), StandardScaler()) X = numpy.array([[0.1, 1.1], [0.2, 2.2], [0.4, 2.2], [0.2, 2.4]]) model.fit(X) model_onnx = convert_sklearn(model, "pipe3", [("input", FloatTensorType([None, 2]))]) filename = "temp_onnx_helper_load_save.onnx" save_onnx_model(model_onnx, filename) model = load_onnx_model(filename) new_model = select_model_inputs_outputs(model, "variable") assert new_model.graph is not None tr1 = self.get_model(model) tr2 = self.get_model(new_model) X = X.astype(numpy.float32) X1 = tr1(X) X2 = tr2(X) assert X1.shape == (4, 2) assert X2.shape == (4, 2)
def test_onnx_helper_load_save(self): model = make_pipeline(StandardScaler(), Binarizer(threshold=0.5)) X = numpy.array([[0.1, 1.1], [0.2, 2.2]]) model.fit(X) model_onnx = convert_sklearn(model, 'binarizer', [('input', FloatTensorType([1, 2]))]) filename = "temp_onnx_helper_load_save.onnx" save_onnx_model(model_onnx, filename) model = load_onnx_model(filename) list(enumerate_model_node_outputs(model)) new_model = select_model_inputs_outputs(model, 'variable') self.assertTrue(new_model.graph is not None) tr1 = self.get_model(model) tr2 = self.get_model(new_model) X = X.astype(numpy.float32) X1 = tr1(X) X2 = tr2(X) self.assertEqual(X1.shape, (2, 2)) self.assertEqual(X2.shape, (2, 2))
def test_onnx_helper_load_save_init(self): model = make_pipeline(Binarizer(), OneHotEncoder(sparse=False), StandardScaler()) X = numpy.array([[0.1, 1.1], [0.2, 2.2], [0.4, 2.2], [0.2, 2.4]]) model.fit(X) model_onnx = convert_sklearn(model, 'pipe3', [('input', FloatTensorType([1, 2]))]) filename = "temp_onnx_helper_load_save.onnx" save_onnx_model(model_onnx, filename) model = load_onnx_model(filename) list(enumerate_model_node_outputs(model)) new_model = select_model_inputs_outputs(model, 'variable') self.assertTrue(new_model.graph is not None) # pylint: disable=E1101 tr1 = self.get_model(model) tr2 = self.get_model(new_model) X = X.astype(numpy.float32) X1 = tr1(X) X2 = tr2(X) self.assertEqual(X1.shape, (4, 2)) self.assertEqual(X2.shape, (4, 2))
# Let's see first the list of intermediate output. model_onnx = load_onnx_model("pipeline_titanic.onnx") for out in enumerate_model_node_outputs(model_onnx): print(out) ################################ # Not that easy to tell which one is what as the *ONNX* # has more operators than the original *scikit-learn* pipelines. # The graph at :ref:`l-plot-complex-pipeline-graph` # helps up to find the outputs of both numerical # and textual pipeline: *variable1*, *variable2*. # Let's look into the numerical pipeline first. num_onnx = select_model_inputs_outputs(model_onnx, 'variable1') save_onnx_model(num_onnx, "pipeline_titanic_numerical.onnx") ################################ # Let's compute the numerical features. sess = rt.InferenceSession("pipeline_titanic_numerical.onnx") numX = sess.run(None, inputs) print("numerical features", numX[0][:1]) ########################################### # We do the same for the textual features. print(model_onnx) text_onnx = select_model_inputs_outputs(model_onnx, 'variable2') save_onnx_model(text_onnx, "pipeline_titanic_textual.onnx") sess = rt.InferenceSession("pipeline_titanic_textual.onnx")
inputs.append(onnx.load_tensor(input_file)) """ # For some models this string has to match the input to the model inputDict = {"image": inputs[0]} outputs_list = [] for out in enumerate_model_node_outputs(model_onnx): outputs_list.append(out) print(outputs_list) for idx, out in enumerate(outputs_list): name = str(idx) + "_" + out dataset = "test_data_set_0" os.mkdir(name) os.mkdir(name + "/" + dataset) modelPath = name + "/" + name + ".onnx" model_output = select_model_inputs_outputs(model_onnx, out) save_onnx_model(model_output, modelPath) sess = rt.InferenceSession(modelPath) numX = sess.run(None, inputDict) print() print("Generating idx=", idx) print(out) print(numX) # hardcoded for 1 output numpy_to_pb(out, numX[0], name + "/" + dataset + "/" + "output_0.pb") numpy_to_pb(out, inputs[0], name + "/" + dataset + "/" + "input_0.pb")
def get_model(self, model): session = InferenceSession(save_onnx_model(model)) return lambda X: session.run(None, {'input': X})[0]