def convert_model(model, name, input_types): """ Runs the appropriate conversion method. :param model: model :return: *onnx* model """ from sklearn.base import BaseEstimator if model.__class__.__name__.startswith("LGBM"): from onnxmltools.convert import convert_lightgbm model, prefix = convert_lightgbm(model, name, input_types), "LightGbm" elif model.__class__.__name__.startswith("XGB"): from onnxmltools.convert import convert_xgboost model, prefix = convert_xgboost(model, name, input_types), "XGB" elif model.__class__.__name__ == 'Booster': import lightgbm if isinstance(model, lightgbm.Booster): from onnxmltools.convert import convert_lightgbm model, prefix = convert_lightgbm(model, name, input_types), "LightGbm" else: raise RuntimeError("Unable to convert model of type '{0}'.".format( type(model))) elif isinstance(model, BaseEstimator): from onnxmltools.convert import convert_sklearn model, prefix = convert_sklearn(model, name, input_types), "Sklearn" else: from onnxmltools.convert import convert_coreml model, prefix = convert_coreml(model, name, input_types), "Cml" if model is None: raise RuntimeError("Unable to convert model of type '{0}'.".format( type(model))) return model, prefix
def _test_lgbm(self, X, model, extra_config={}): # Create ONNX-ML model onnx_ml_model = convert_lightgbm( model, initial_types=[("input", FloatTensorType([X.shape[0], X.shape[1]]))], target_opset=9) # Create ONNX model onnx_model = convert(onnx_ml_model, "onnx", extra_config=extra_config) # Get the predictions for the ONNX-ML model session = ort.InferenceSession(onnx_ml_model.SerializeToString()) output_names = [ session.get_outputs()[i].name for i in range(len(session.get_outputs())) ] onnx_ml_pred = [[] for i in range(len(output_names))] inputs = {session.get_inputs()[0].name: X} pred = session.run(output_names, inputs) for i in range(len(output_names)): if "label" in output_names[i]: onnx_ml_pred[1] = pred[i] else: onnx_ml_pred[0] = pred[i] # Get the predictions for the ONNX model onnx_pred = [[] for i in range(len(output_names))] if len(output_names) == 1: # regression onnx_pred = onnx_model.predict(X) else: # classification onnx_pred[0] = onnx_model.predict_proba(X) onnx_pred[1] = onnx_model.predict(X) return onnx_ml_pred, onnx_pred, output_names
def test_lightgbm_classifier_nozipmap2(self): X = [[0, 1], [1, 1], [2, 0], [1, 2], [1, 5], [6, 2]] X = numpy.array(X, dtype=numpy.float32) y = [0, 1, 0, 1, 1, 0] model = LGBMClassifier(n_estimators=3, min_child_samples=1, max_depth=2) model.fit(X, y) onx = convert_lightgbm(model, 'dummy', initial_types=[ ('X', FloatTensorType([None, X.shape[1]])) ], zipmap=False) assert "zipmap" not in str(onx).lower() onxs = onx.SerializeToString() try: sess = onnxruntime.InferenceSession(onxs) except Exception as e: raise AssertionError( "Model cannot be loaded by onnxruntime due to %r\n%s." % (e, onx[0])) exp = model.predict(X), model.predict_proba(X) got = sess.run(None, {'X': X}) assert_almost_equal(exp[0], got[0]) assert_almost_equal(exp[1], got[1])
def test_lightgbm_onnx_pytorch(self): warnings.filterwarnings("ignore") X = [[0, 1], [1, 1], [2, 0]] X = np.array(X, dtype=np.float32) y = np.array([100, -10, 50], dtype=np.float32) model = lgb.LGBMRegressor(n_estimators=3, min_child_samples=1) model.fit(X, y) # Create ONNX-ML model onnx_ml_model = convert_lightgbm( model, initial_types=[("input", FloatTensorType([X.shape[0], X.shape[1]]))], target_opset=9) pt_model = convert(onnx_ml_model, "torch", X) assert pt_model # Get the predictions for the ONNX-ML model session = ort.InferenceSession(onnx_ml_model.SerializeToString()) output_names = [ session.get_outputs()[i].name for i in range(len(session.get_outputs())) ] onnx_ml_pred = [[] for i in range(len(output_names))] inputs = {session.get_inputs()[0].name: X} onnx_ml_pred = session.run(output_names, inputs) np.testing.assert_allclose(onnx_ml_pred[0].flatten(), pt_model.predict(X))
def convert_model(model, name, input_types): """ Runs the appropriate conversion method. :param model: model, *scikit-learn*, *keras*, or *coremltools* object :return: *onnx* model """ from sklearn.base import BaseEstimator if model.__class__.__name__.startswith("LGBM"): from onnxmltools.convert import convert_lightgbm model, prefix = convert_lightgbm(model, name, input_types), "LightGbm" elif isinstance(model, BaseEstimator): from onnxmltools.convert import convert_sklearn model, prefix = convert_sklearn(model, name, input_types), "Sklearn" else: from keras.models import Model if isinstance(model, Model): from onnxmltools.convert import convert_keras model, prefix = convert_keras(model, name, input_types), "Keras" else: from onnxmltools.convert import convert_coreml model, prefix = convert_coreml(model, name, input_types), "Cml" if model is None: raise RuntimeError("Unable to convert model of type '{0}'.".format(type(model))) return model, prefix
def test_lightgbm_pytorch_extra_config(self): warnings.filterwarnings("ignore") X = [[0, 1], [1, 1], [2, 0]] X = np.array(X, dtype=np.float32) y = np.array([100, -10, 50], dtype=np.float32) model = lgb.LGBMRegressor(n_estimators=3, min_child_samples=1) model.fit(X, y) # Create ONNX-ML model onnx_ml_model = convert_lightgbm( model, initial_types=[("input", FloatTensorType([X.shape[0], X.shape[1]]))], target_opset=9) # Create ONNX model model_name = "hummingbird.ml.test.lightgbm" extra_config = {} extra_config[constants.ONNX_OUTPUT_MODEL_NAME] = model_name extra_config[constants.ONNX_INITIAL_TYPES] = [ ("input", FloatTensorType([X.shape[0], X.shape[1]])) ] onnx_model = convert(onnx_ml_model, "onnx", extra_config=extra_config) assert onnx_model.model.graph.name == model_name
def test_lightgbm_regressor(self): try: from onnxmltools import __version__ except ImportError: return if compare_module_version(__version__, '1.11') <= 0: return from lightgbm import LGBMRegressor try: from onnxmltools.convert import convert_lightgbm except ImportError: convert_lightgbm = None X, y = self.data_X, self.data_y for ne in [1, 2, 10, 50, 100, 200]: for mx in [1, 10]: if __name__ != "__main__" and mx > 5: break model = LGBMRegressor(max_depth=mx, n_estimators=ne, min_child_samples=1, learning_rate=0.0000001) model.fit(X, y) expected = model.predict(X) model_onnx = to_onnx(model, X) if convert_lightgbm is not None: try: model_onnx2 = convert_lightgbm( model, initial_types=[('X', FloatTensorType([None, X.shape[1]]))]) except RuntimeError as e: if "is higher than the number of the installed" in str( e): model_onnx2 = None else: raise e else: model_onnx2 = None for i, mo in enumerate([model_onnx, model_onnx2]): if mo is None: continue for rt in ['python', 'onnxruntime1']: with self.subTest(i=i, rt=rt, max_depth=mx, n_est=ne): oinf = OnnxInference(mo, runtime=rt) got = oinf.run({'X': X})['variable'] diff = numpy.abs(got.ravel() - expected.ravel()).max() if __name__ == "__main__": print("lgb1 mx=%d ne=%d" % (mx, ne), "mlprod" if i == 0 else "mltool", rt[:6], diff) self.assertLess(diff, 1e-3)
def test_lightgbm_pytorch(self): warnings.filterwarnings("ignore") X = [[0, 1], [1, 1], [2, 0]] X = np.array(X, dtype=np.float32) y = np.array([100, -10, 50], dtype=np.float32) model = lgb.LGBMRegressor(n_estimators=3, min_child_samples=1) model.fit(X, y) # Create ONNX-ML model onnx_ml_model = convert_lightgbm( model, initial_types=[("input", FloatTensorType([X.shape[0], X.shape[1]]))], target_opset=9 ) self.assertRaises(RuntimeError, convert, onnx_ml_model, "torch")
ONNX_TRANS_PATH = env.str('TRANS_PATH', './outputs/trans.onnx') ONNX_MODEl_PATH_XGB = env.str('ONNX_MODEl_PATH_XGB', './outputs/xgb.onnx') ONNX_MODEl_PATH_LGB = env.str('ONNX_MODEl_PATH_LGB', './outputs/lgb.onnx') ONNX_MODEl_PATH_DCN = env.str('ONNX_MODEl_PATH_DCN', './outputs/dcn.onnx') trans_initial_type = [('num_feat', FloatTensorType([None, 13])), ('cat_feat', StringTensorType([None, 26]))] model_initial_type = [('num_feat', FloatTensorType([None, 39]))] print('convert sklearn transformer') trans = joblib.load(TRANS_PATH) onx = convert_sklearn(trans, initial_types=trans_initial_type) onnx.save(onx, ONNX_TRANS_PATH) print('convert XGBoost model') model = xgb.XGBClassifier() model.load_model(MODEL_PATH_XGB) onx = convert_xgboost(model, initial_types=model_initial_type) onnx.save(onx, ONNX_MODEl_PATH_XGB) print('convert LightGBM model') model = lgb.Booster(model_file=MODEL_PATH_LGB) onx = convert_lightgbm(model, initial_types=model_initial_type) onnx.save(onx, ONNX_MODEl_PATH_LGB) print('convert DCN model') graph_def, inputs, outputs = from_saved_model(MODEL_PATH_DCN, None, None) tf.compat.v1.disable_eager_execution() onx = convert_tensorflow(graph_def, input_names=inputs, output_names=outputs) onnx.save(onx, ONNX_MODEl_PATH_DCN)
from onnxconverter_common.data_types import FloatTensorType from onnxmltools.convert import convert_lightgbm iris = load_iris() X, y = iris.data, iris.target X_train, X_test, y_train, y_test = train_test_split(X, y) clr = LGBMClassifier() clr.fit(X_train, y_train) print(clr) ########################### # Convert a model into ONNX # +++++++++++++++++++++++++ initial_type = [('float_input', FloatTensorType([None, 4]))] onx = convert_lightgbm(clr, initial_types=initial_type) ################################### # Compute the predictions with onnxruntime # ++++++++++++++++++++++++++++++++++++++++ sess = rt.InferenceSession(onx.SerializeToString()) input_name = sess.get_inputs()[0].name label_name = sess.get_outputs()[0].name pred_onx = sess.run([label_name], {input_name: X_test.astype(numpy.float32)})[0] print(pred_onx) ############################################### # With Dataset # ++++++++++++
# In[2]: # Create and train a model (LightGBM in this case). model = lgb.LGBMClassifier() model.fit(X, y) # In[3]: # Use ONNXMLTOOLS to convert the model to ONNXML. initial_types = [("input", FloatTensorType([X.shape[0], X.shape[1]]))] # Define the inputs for the ONNX onnx_ml_model = convert_lightgbm( model, initial_types=initial_types, target_opset=9 ) # In[4]: # Use Hummingbird to convert the ONNXML model to ONNX. onnx_model = convert(onnx_ml_model, "onnx", X) # In[5]: # Alternatively we can set the inital types using the extra_config parameters as in the ONNXMLTOOL converter. extra_config = {}