def test_glm_classifier(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[y == 2] = 1
# scikit-learn has changed the default value for multi_class.
lr = LogisticRegression(multi_class='ovr')
lr.fit(X, y)
lr_coreml = coremltools.converters.sklearn.convert(lr)
lr_onnx = convert(lr_coreml.get_spec())
self.assertTrue(lr_onnx is not None)
self.validate_zipmap(lr_onnx)
dump_data_and_model(X.astype(numpy.float32), lr, lr_onnx, basename="CmlbinLogitisticRegression",
allow_failure="StrictVersion(onnx.__version__) < StrictVersion('1.3.0')")
# Ensure there is a probability output
svm = LinearSVC()
svm.fit(X, y)
svm_coreml = coremltools.converters.sklearn.convert(svm)
svm_onnx = convert(svm_coreml.get_spec())
self.assertTrue(svm_onnx is not None)
self.validate_zipmap(svm_onnx)
dump_data_and_model(X.astype(numpy.float32), svm, svm_onnx, basename="CmlBinLinearSVC-NoProb",
allow_failure=True)
def test_lightgbm_booster_multi_classifier(self):
X = [[0, 1], [1, 1], [2, 0], [1, 2], [-1, 2], [1, -2]]
X = numpy.array(X, dtype=numpy.float32)
y = [0, 1, 0, 1, 2, 2]
data = lightgbm.Dataset(X, label=y)
model = lightgbm.train(
{
'boosting_type': 'gbdt',
'objective': 'multiclass',
'n_estimators': 3,
'min_child_samples': 1,
'num_class': 3
}, data)
model_onnx, prefix = convert_model(
model, 'tree-based classifier',
[('input', FloatTensorType([None, 2]))])
dump_data_and_model(
X,
model,
model_onnx,
allow_failure=
"StrictVersion(onnx.__version__) < StrictVersion('1.3.0')",
basename=prefix + "BoosterBin" + model.__class__.__name__)
try:
from onnxruntime import InferenceSession
except ImportError:
# onnxruntime not installed (python 2.7)
return
sess = InferenceSession(model_onnx.SerializeToString())
out = sess.get_outputs()
names = [o.name for o in out]
assert names == ['label', 'probabilities']
def test_catboost_bin_classifier(self):
import onnxruntime
from distutils.version import StrictVersion
if StrictVersion(onnxruntime.__version__) >= StrictVersion('1.3.0'):
X, y = make_classification(n_samples=100,
n_features=4,
random_state=0)
catboost_model = catboost.CatBoostClassifier(
task_type='CPU',
loss_function='CrossEntropy',
n_estimators=10,
verbose=0)
catboost_model.fit(X.astype(numpy.float32), y)
catboost_onnx = convert_catboost(
catboost_model,
name='CatBoostBinClassification',
doc_string='test binary classification')
self.assertTrue(catboost_onnx is not None)
dump_data_and_model(X.astype(numpy.float32),
catboost_model,
catboost_onnx,
basename="CatBoostBinClass")
else:
warnings.warn(
'Converted CatBoost models for binary classification work with onnxruntime version 1.3.0 or '
'a newer one')
def test_convert_nusvmc(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[y == 2] = 1
prob = svmutil.svm_problem(y, X.tolist())
param = svmutil.svm_parameter()
param.svm_type = NuSVC
param.kernel_type = svmutil.RBF
param.eps = 1
param.probability = 1
if noprint:
param.print_func = noprint
libsvm_model = svmutil.svm_train(prob, param)
node = convert(libsvm_model, "LibSvmNuSvmc",
[('input', FloatTensorType(shape=['None', 'None']))])
self.assertTrue(node is not None)
dump_data_and_model(
X[:5].astype(numpy.float32),
SkAPIClProba2(libsvm_model),
node,
basename="LibSvmNuSvmc-Dec2",
allow_failure=
"StrictVersion(onnxruntime.__version__) <= StrictVersion('0.1.3')")
def test_convert_svmc(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[y == 2] = 1
prob = svmutil.svm_problem(y, X.tolist())
param = svmutil.svm_parameter()
param.svm_type = SVC
param.kernel_type = svmutil.RBF
param.eps = 1
param.probability = 1
if noprint:
param.print_func = noprint
libsvm_model = svmutil.svm_train(prob, param)
node = convert(libsvm_model, "LibSvmSvmc",
[('input', FloatTensorType())])
self.assertTrue(node is not None)
dump_data_and_model(X[:5].astype(numpy.float32),
SkAPIClProba2(libsvm_model),
node,
basename="LibSvmSvmc-Dec2")
def test_custom_op(self):
N, C, H, W = 2, 3, 5, 5
x = np.random.rand(N, H, W, C).astype(np.float32, copy=False)
model = Sequential()
model.add(
Conv2D(2,
kernel_size=(1, 2),
strides=(1, 1),
padding='valid',
input_shape=(H, W, C),
data_format='channels_last'))
model.add(ScaledTanh(0.9, 2.0))
model.add(
MaxPooling2D((2, 2), strides=(2, 2), data_format='channels_last'))
model.compile(optimizer='sgd', loss='mse')
converted_model = onnxmltools.convert_keras(
model, custom_conversion_functions={ScaledTanh: custom_activation})
actual = model.predict(x)
self.assertIsNotNone(actual)
self.assertIsNotNone(converted_model)
dump_data_and_model(x.astype(np.float32),
model,
converted_model,
basename="KerasCustomOp-Out0",
context=dict(ScaledTanh=ScaledTanh))
def test_convert_svmc_linear_raw_multi(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[-5:] = 3
prob = svmutil.svm_problem(y, X.tolist())
param = svmutil.svm_parameter()
param.svm_type = SVC
param.kernel_type = svmutil.LINEAR
param.eps = 1
param.probability = 0
if noprint:
param.print_func = noprint
libsvm_model = svmutil.svm_train(prob, param)
node = convert(libsvm_model, "LibSvmNuSvmcMultiRaw",
[('input', FloatTensorType(shape=['None', 2]))])
self.assertTrue(node is not None)
X2 = numpy.vstack([X[:2], X[60:62], X[110:112],
X[147:149]]) # 5x0, 5x1
dump_data_and_model(
X2.astype(numpy.float32),
SkAPICl(libsvm_model),
node,
basename="LibSvmSvmcRaw-Dec3",
verbose=False,
allow_failure=
"StrictVersion(onnxruntime.__version__) <= StrictVersion('0.1.3')")
def test_xgb_classifier_multi_discrete_int_labels(self):
iris = load_iris()
x = iris.data[:, :2]
y = iris.target
y[y == 0] = 10
y[y == 1] = 20
y[y == 2] = -30
x_train, x_test, y_train, _ = train_test_split(x,
y,
test_size=0.5,
random_state=42)
xgb = XGBClassifier(n_estimators=3)
xgb.fit(x_train, y_train)
conv_model = convert_xgboost(xgb,
initial_types=[
('input',
FloatTensorType(shape=[None, None]))
])
self.assertTrue(conv_model is not None)
dump_data_and_model(
x_test.astype("float32"),
xgb,
conv_model,
basename="SklearnXGBClassifierMultiDiscreteIntLabels",
allow_failure="StrictVersion("
"onnx.__version__)"
"< StrictVersion('1.3.0')",
)
def test_xgboost_classifier_i5450(self):
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X,
y,
random_state=10)
clr = XGBClassifier(objective="multi:softmax",
max_depth=1,
n_estimators=2)
clr.fit(X_train,
y_train,
eval_set=[(X_test, y_test)],
early_stopping_rounds=40)
initial_type = [('float_input', FloatTensorType([None, 4]))]
onx = convert_xgboost(clr, initial_types=initial_type)
sess = InferenceSession(onx.SerializeToString())
input_name = sess.get_inputs()[0].name
label_name = sess.get_outputs()[1].name
predict_list = [1., 20., 466., 0.]
predict_array = np.array(predict_list).reshape(
(1, -1)).astype(np.float32)
pred_onx = sess.run([label_name], {input_name: predict_array})[0]
pred_xgboost = sessresults = clr.predict_proba(predict_array)
bst = clr.get_booster()
bst.dump_model('dump.raw.txt')
dump_data_and_model(
X_test.astype(np.float32) + 1e-5,
clr,
onx,
allow_failure=
"StrictVersion(onnx.__version__) < StrictVersion('1.3.0')",
basename="XGBClassifierIris")
def test_xgboost_booster_classifier_reg(self):
x, y = make_classification(n_classes=2,
n_features=5,
n_samples=100,
random_state=42,
n_informative=3)
y = y.astype(np.float32) + 0.567
x_train, x_test, y_train, _ = train_test_split(x,
y,
test_size=0.5,
random_state=42)
data = DMatrix(x_train, label=y_train)
model = train(
{
'objective': 'reg:squarederror',
'n_estimators': 3,
'min_child_samples': 1
}, data)
model_onnx = convert_xgboost(
model, 'tree-based classifier',
[('input', FloatTensorType([None, x.shape[1]]))])
dump_data_and_model(
x_test.astype(np.float32),
model,
model_onnx,
allow_failure=
"StrictVersion(onnx.__version__) < StrictVersion('1.3.0')",
basename="XGBBoosterReg")
def test_convert_svmc_raw(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[y == 2] = 1
prob = svmutil.svm_problem(y, X.tolist())
param = svmutil.svm_parameter()
param.svm_type = SVC
param.kernel_type = svmutil.RBF
param.eps = 1
param.probability = 0
if noprint:
param.print_func = noprint
libsvm_model = svmutil.svm_train(prob, param)
# known svm runtime dimension error in ONNX Runtime
node = convert(libsvm_model, "LibSvmSvmcRaw",
[('input', FloatTensorType(shape=['None', 'None']))])
self.assertTrue(node is not None)
dump_data_and_model(
X[:5].astype(numpy.float32),
SkAPICl(libsvm_model),
node,
basename="LibSvmSvmcRaw",
allow_failure=
"StrictVersion(onnxruntime.__version__) < StrictVersion('0.5.0')")
def test_lightgbm_booster_regressor(self):
X = [[0, 1], [1, 1], [2, 0]]
X = numpy.array(X, dtype=numpy.float32)
y = [0, 1, 1.1]
data = lightgbm.Dataset(X, label=y)
model = lightgbm.train(
{
'boosting_type': 'gbdt',
'objective': 'regression',
'n_estimators': 3,
'min_child_samples': 1,
'max_depth': 1
}, data)
model_onnx, prefix = convert_model(
model,
'tree-based binary classifier',
[('input', FloatTensorType([None, 2]))],
without_onnx_ml=True)
dump_data_and_model(
X,
model,
model_onnx,
allow_failure=
"StrictVersion(onnx.__version__) < StrictVersion('1.0.0')",
basename=prefix + "BoosterBin" + model.__class__.__name__)
def test_xgb_regressor(self):
iris = load_diabetes()
x = iris.data
y = iris.target
x_train, x_test, y_train, _ = train_test_split(x,
y,
test_size=0.5,
random_state=42)
xgb = XGBRegressor()
xgb.fit(x_train, y_train)
conv_model = convert_xgboost(xgb,
initial_types=[
('input',
FloatTensorType(shape=[None, None]))
])
self.assertTrue(conv_model is not None)
dump_data_and_model(
x_test.astype("float32"),
xgb,
conv_model,
basename="SklearnXGBRegressor-Dec3",
allow_failure="StrictVersion("
"onnx.__version__)"
"< StrictVersion('1.3.0')",
)
def test_convert_svmc_linear_raw(self):
iris = load_iris()
X = iris.data[:, :2]
y = iris.target
y[y == 2] = 1
prob = svmutil.svm_problem(y, X.tolist())
param = svmutil.svm_parameter()
param.svm_type = SVC
param.kernel_type = svmutil.LINEAR
param.eps = 1
param.probability = 0
if noprint:
param.print_func = noprint
libsvm_model = svmutil.svm_train(prob, param)
node = convert(libsvm_model, "LibSvmSvmcLinearRaw",
[('input', FloatTensorType(shape=[1, 'None']))])
self.assertTrue(node is not None)
dump_data_and_model(
X[:5].astype(numpy.float32),
SkAPICl(libsvm_model),
node,
basename="LibSvmSvmcLinearRaw-Dec3",
verbose=False,
allow_failure=
"StrictVersion(onnxruntime.__version__) <= StrictVersion('0.1.4')")
def test_xgboost_example_mnist(self):
"""
Train a simple xgboost model and store associated artefacts.
"""
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y)
X_train = X_train.reshape((X_train.shape[0], -1))
X_test = X_test.reshape((X_test.shape[0], -1))
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
clf = XGBClassifier(objective="multi:softprob", n_jobs=-1)
clf.fit(X_train, y_train)
sh = [None, X_train.shape[1]]
onnx_model = convert_xgboost(clf,
initial_types=[('input',
FloatTensorType(sh))])
dump_data_and_model(
X_test.astype(np.float32),
clf,
onnx_model,
allow_failure=
"StrictVersion(onnx.__version__) < StrictVersion('1.3.0')",
basename="XGBoostExample")
def test_h2o_classifier_multi_int(self):
gbm = H2OGradientBoostingEstimator(ntrees=9, max_depth=5)
mojo_path, test_data = _train_classifier(gbm, 9, is_str=False)
onnx_model = _convert_mojo(mojo_path)
self.assertIsNot(onnx_model, None)
dump_data_and_model(
test_data, H2OMojoWrapper(mojo_path), onnx_model,
basename="H2OClassMultiBin")
def test_robust_scaler_floats_no_scaling(self):
model = RobustScaler(with_scaling=False)
data = [[0., 0., 3.], [1., 1., 0.], [0., 2., 1.], [1., 0., 2.]]
model.fit(data)
model_onnx = convert_sklearn(model, 'scaler', [('input', FloatTensorType([1, 3]))])
self.assertTrue(model_onnx is not None)
dump_data_and_model(numpy.array(data, dtype=numpy.float32),
model, basename="SklearnRobustScalerNoScalingFloat32")
def test_h2o_classifier_bin_int(self):
gbm = H2OGradientBoostingEstimator(ntrees=8, max_depth=5)
mojo_path, test_data = _train_classifier(gbm, 2, is_str=False, force_y_numeric=True)
onnx_model = _convert_mojo(mojo_path)
self.assertIsNot(onnx_model, None)
dump_data_and_model(
test_data, H2OMojoWrapper(mojo_path), onnx_model,
basename="H2OClassBinInt")
def test_scaler(self):
model = StandardScaler()
data = numpy.array([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]], dtype=numpy.float32)
model.fit(data)
model_coreml = coremltools.converters.sklearn.convert(model)
model_onnx = convert(model_coreml.get_spec())
self.assertTrue(model_onnx is not None)
dump_data_and_model(data, model, model_onnx, basename="CmlStandardScalerFloat32")
def test_standard_scaler(self):
model = StandardScaler()
data = [[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]
model.fit(data)
model_onnx = convert_sklearn(model, 'scaler', [('input', Int64TensorType([1, 3]))])
self.assertTrue(model_onnx is not None)
dump_data_and_model(numpy.array(data, dtype=numpy.int64),
model, model_onnx, basename="SklearnStandardScalerInt64")
def test_max_abs_scaler(self):
model = MaxAbsScaler()
data = [[0., 0., 3.], [1., 1., 0.], [0., 2., 1.], [1., 0., 2.]]
model.fit(data)
model_onnx = convert_sklearn(model, 'scaler', [('input', FloatTensorType([1, 3]))])
self.assertTrue(model_onnx is not None)
dump_data_and_model(numpy.array(data, dtype=numpy.float32),
model, basename="SklearnMaxAbsScaler")
def test_model_linear_svc_multi_class(self):
model, X = self._fit_model_multiclass_classification(LinearSVC())
model_onnx = convert_sklearn(model, 'multi-class linear SVC',
[('input', FloatTensorType([1, 3]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="SklearnLinearSVCMulti")
def test_model_binarizer(self):
model = Binarizer(threshold=0.5)
model_onnx = convert_sklearn(model, 'scikit-learn binarizer',
[('input', FloatTensorType([1, 1]))])
self.assertTrue(model_onnx is not None)
dump_data_and_model(numpy.array([[1, 1]], dtype=numpy.float32),
model,
model_onnx,
basename="SklearnBinarizer-SkipDim1")
def test_support_vector_regressor(self):
X, y = make_regression(n_features=4, random_state=0)
svm = SVR(gamma=1./len(X))
svm.fit(X, y)
svm_coreml = coremltools.converters.sklearn.convert(svm)
svm_onnx = convert(svm_coreml.get_spec())
self.assertTrue(svm_onnx is not None)
dump_data_and_model(X.astype(numpy.float32), svm, svm_onnx, basename="CmlRegSVR-Dec3")
def test_dict_vectorizer(self):
model = DictVectorizer()
data = [{'amy': 1., 'chin': 200.}, {'nice': 3., 'amy': 1.}]
model.fit_transform(data)
model_coreml = coremltools.converters.sklearn.convert(model)
model_onnx = convert(model_coreml.get_spec())
self.assertTrue(model_onnx is not None)
dump_data_and_model(data, model, model_onnx, basename="CmlDictVectorizer-OneOff-SkipDim1",
allow_failure="StrictVersion(onnx.__version__) < StrictVersion('1.3.0')")
def test_truncated_svd(self):
N, C, K = 2, 3, 2
x = create_tensor(N, C)
svd = TruncatedSVD(n_components=K)
svd.fit(x)
model_onnx = onnxmltools.convert_sklearn(
svd, initial_types=[('input', FloatTensorType(shape=[1, C]))])
self.assertTrue(model_onnx is not None)
dump_data_and_model(x, svd, model_onnx, basename="SklearnTruncatedSVD")
def test_tree_ensemble_regressor(self):
X, y = make_regression(n_features=4, random_state=0)
model = RandomForestRegressor().fit(X, y)
model_coreml = coremltools.converters.sklearn.convert(model)
model_onnx = convert(model_coreml.get_spec())
self.assertTrue(model_onnx is not None)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="CmlRegRandomForestRegressor-Dec3")
def test_model_logistic_regression_multi_class(self):
model, X = self._fit_model_multiclass_classification(
linear_model.LogisticRegression())
model_onnx = convert_sklearn(model, 'maximum entropy classifier',
[('input', FloatTensorType([1, 3]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="SklearnLogitisticRegressionMulti")
def test_model_logistic_regression_binary_class(self):
model, X = self._fit_model_binary_classification(
linear_model.LogisticRegression())
model_onnx = convert_sklearn(model, 'logistic regression',
[('input', FloatTensorType([1, 3]))])
self.assertIsNotNone(model_onnx)
dump_data_and_model(X.astype(numpy.float32),
model,
model_onnx,
basename="SklearnLogitisticRegressionBinary")
def test_model_normalizer_float(self):
model = Normalizer(norm='l2')
model_onnx = convert_sklearn(model, 'scikit-learn normalizer',
[('input', FloatTensorType([1, 1]))])
self.assertTrue(model_onnx is not None)
self.assertTrue(len(model_onnx.graph.node) == 1)
dump_data_and_model(numpy.array([[1, 1]], dtype=numpy.float32),
model,
model_onnx,
basename="SklearnNormalizerL2-SkipDim1")
