Fix exporter to tf2onnx

_unittests/ut_onnx_conv/test_onnxrt_runtime_lightgbm.py

@@ -26,6 +26,7 @@ def setUp(self):
         register_converters()
 
     @unittest.skipIf(sys.platform == 'darwin', 'stuck')
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_missing(self):
         from mlprodict.onnx_conv.operator_converters.parse_lightgbm import (
             WrappedLightGbmBooster)
@@ -372,6 +373,7 @@ def test_onnxrt_python_lightgbm_categorical_iris_dataframe(self):
 
     @skipif_circleci('stuck')
     @unittest.skipIf(sys.platform == 'darwin', 'stuck')
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_lightgbm_booster_classifier(self):
         from lightgbm import Dataset, train as lgb_train
 
@@ -413,6 +415,7 @@ def _assert_almost_equal(self, actual, desired, decimal=7, frac=1.0, msg=""):
 
     @skipif_circleci('stuck')
     @unittest.skipIf(sys.platform == 'darwin', 'stuck')
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_missing_values(self):
         from lightgbm import LGBMRegressor
 
@@ -470,6 +473,7 @@ def _predict_with_onnx(model, X):
 
     @skipif_circleci('stuck')
     @unittest.skipIf(sys.platform == 'darwin', 'stuck')
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_objective(self):
         from lightgbm import LGBMRegressor
 
@@ -498,6 +502,40 @@ def test_objective(self):
                     y_pred, y_pred_onnx, decimal=_N_DECIMALS, frac=_FRAC,
                     msg="Objective=%r" % objective)
 
+    @skipif_circleci('stuck')
+    @unittest.skipIf(sys.platform == 'darwin', 'stuck')
+    @ignore_warnings((RuntimeWarning, UserWarning))
+    def test_objective_boosting_rf(self):
+        from lightgbm import LGBMRegressor
+
+        _N_ROWS = 10000
+        _N_COLS = 10
+        _N_DECIMALS = 5
+        _FRAC = 0.9997
+
+        _X = pandas.DataFrame(numpy.random.random(
+            size=(_N_ROWS, _N_COLS)).astype(numpy.float32))
+        _Y = pandas.Series(numpy.random.random(size=_N_ROWS))
+
+        _objectives = ("regression",)
+
+        for objective in _objectives:
+            with self.subTest(X=_X, objective=objective):
+                initial_types = self._calc_initial_types(_X)
+                regressor = LGBMRegressor(
+                    objective=objective, boosting='rf', bagging_freq=3,
+                    bagging_fraction=0.5, n_estimators=10)
+                regressor.fit(_X, _Y)
+                regressor_onnx = to_onnx(
+                    regressor, initial_types=initial_types,
+                    rewrite_ops=True)
+                y_pred = regressor.predict(_X)
+                y_pred_onnx = self._predict_with_onnx(regressor_onnx, _X) / 10
+                self._assert_almost_equal(
+                    y_pred, y_pred_onnx, decimal=_N_DECIMALS, frac=_FRAC,
+                    msg="Objective=%r" % objective)
+
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_lgbm_regressor10(self):
         from lightgbm import LGBMRegressor
         data = load_iris()
@@ -523,6 +561,7 @@ def test_lgbm_regressor10(self):
         self.assertEqualArray(expected, got1, decimal=5)
         self.assertEqualArray(expected, got2, decimal=5)
 
+    @ignore_warnings((RuntimeWarning, UserWarning))
     def test_lgbm_regressor(self):
         from lightgbm import LGBMRegressor
         data = load_iris()

_unittests/ut_onnxrt/test_onnxrt_python_runtime_.py

@@ -3511,7 +3511,7 @@ def test_onnxt_runtime_size(self):
 
     @wraplog()
     def test_onnxt_runtime_slice(self):
-        for opset in [9, get_opset_number_from_onnx()]:
+        for opset in range(9, get_opset_number_from_onnx() + 1):
             if opset > get_opset_number_from_onnx():
                 continue
             with self.subTest(opset=opset):

_unittests/ut_sklapi/test_onnx_speedup_regressor.py

@@ -29,7 +29,7 @@ def setUp(self):
     def opset(self):
         return get_opset_number_from_onnx()
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor32(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -38,7 +38,17 @@ def test_speedup_regressor32(self):
         spd.fit(X, y)
         spd.assert_almost_equal(X, decimal=5)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
+    def test_speedup_regressor32_weights(self):
+        data = load_iris()
+        X, y = data.data, data.target
+        weights = (y.copy() + 1).astype(X.dtype)
+        spd = OnnxSpeedupRegressor(
+            LinearRegression(), target_opset=self.opset())
+        spd.fit(X, y, weights)
+        spd.assert_almost_equal(X, decimal=5)
+
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor32_onnxruntime(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -48,7 +58,7 @@ def test_speedup_regressor32_onnxruntime(self):
         spd.fit(X, y)
         spd.assert_almost_equal(X, decimal=5)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor32_numpy(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -58,7 +68,7 @@ def test_speedup_regressor32_numpy(self):
         spd.fit(X, y)
         spd.assert_almost_equal(X, decimal=5)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor32_numba(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -70,7 +80,7 @@ def test_speedup_regressor32_numba(self):
         spd.assert_almost_equal(X, decimal=5)
         self.assertIn("CPUDispatch", str(spd.onnxrt_.func))
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -80,7 +90,7 @@ def test_speedup_regressor64(self):
         spd.fit(X, y)
         spd.assert_almost_equal(X)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_op_version(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -91,7 +101,7 @@ def test_speedup_regressor64_op_version(self):
         opset = spd.op_version
         self.assertGreater(self.opset(), opset[''])
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_pickle(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -112,7 +122,7 @@ def test_speedup_regressor64_pickle(self):
         got = spd2.raw_predict(X)
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_numpy_pickle(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -133,7 +143,7 @@ def test_speedup_regressor64_numpy_pickle(self):
         got = spd2.raw_predict(X)
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_numba_pickle(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -154,7 +164,7 @@ def test_speedup_regressor64_numba_pickle(self):
         got = spd2.raw_predict(X)
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_onnx(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -168,7 +178,7 @@ def test_speedup_regressor64_onnx(self):
         got = oinf.run({'X': X})['variable']
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_onnx_numpy(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -182,7 +192,7 @@ def test_speedup_regressor64_onnx_numpy(self):
         got = oinf.run({'X': X})['variable']
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_onnx_numba(self):
         data = load_iris()
         X, y = data.data, data.target
@@ -197,7 +207,7 @@ def test_speedup_regressor64_onnx_numba(self):
         got = oinf.run({'X': X})['variable']
         self.assertEqualArray(expected, got)
 
-    @ignore_warnings(ConvergenceWarning)
+    @ignore_warnings((ConvergenceWarning, DeprecationWarning))
     def test_speedup_regressor64_onnx_numba_python(self):
         data = load_iris()
         X, y = data.data, data.target