Enhance OrdinalEncoder conversion to handle infrequent categories (#1195)

* Enhance OrdinalEncoder conversion to handle infrequent categories

- Added logic to check if infrequent categories are enabled in the OrdinalEncoder.
- Introduced handling for `infrequent_categories_` to adjust `values_int64s` accordingly.
- Updated conversion process to account for `max_categories` or `min_frequency` by modifying the attribute values for infrequent categories.

Signed-off-by: Danil Petrov <[email protected]>

* Refactor handling of infrequent categories in OrdinalEncoder conversion

- Replaced `current_infrequent_categories_` with `default_to_infrequent_mappings` for clarity.
- Updated logic to handle `default_to_infrequent_mappings` when encoding missing values.
- Simplified the assignment of `attrs["values_int64s"]` by using `default_to_infrequent_mappings` where applicable.
- Ensured consistent handling of `max_categories` or `min_frequency` scenarios.

Signed-off-by: Danil Petrov <[email protected]>

* Fix linting

Signed-off-by: Danil Petrov <[email protected]>

* Enable conversion of OrdinalEncoder with max_categories and min_frequency

- Added `max_categories_support` function to check scikit-learn version >= 1.3 for `max_categories` and `min_frequency` support in `OrdinalEncoder`.
- Updated tests to skip tests if `max_categories` and `min_frequency` are not supported.
- Added a check for `_infrequent_enabled` attribute before accessing it to ensure compatibility with older versions of scikit-learn.

Signed-off-by: Danil Petrov <[email protected]>

* Improve infrequent category handling and missing value encoding in OrdinalEncoder conversion

- Modified the condition for checking `_infrequent_enabled` to improve readability.
- Ensured correct concatenation of `encoded_missing_value` with `values_int64s` when `default_to_infrequent_mappings` is not None.
- Added a test case `SklearnOrdinalEncoderCatList` to verify the conversion of `OrdinalEncoder` with a list of categories.
- Updated `dump_data_and_model` call in `SklearnOrdinalEncoderCatList` test for better readability.

Signed-off-by: Danil Petrov <[email protected]>

---------

Signed-off-by: Danil Petrov <[email protected]>
Co-authored-by: Xavier Dupré <[email protected]>

Author: dpetrovb

skl2onnx/operator_converters/ordinal_encoder.py

@@ -34,6 +34,16 @@ def convert_sklearn_ordinal_encoder(
         if len(categories) == 0:
             continue
 
+        if (
+            hasattr(ordinal_op, "_infrequent_enabled")
+            and ordinal_op._infrequent_enabled
+        ):
+            default_to_infrequent_mappings = ordinal_op._default_to_infrequent_mappings[
+                input_idx
+            ]
+        else:
+            default_to_infrequent_mappings = None
+
         current_input = operator.inputs[input_idx]
         if current_input.get_second_dimension() == 1:
             feature_column = current_input
@@ -113,11 +123,30 @@ def convert_sklearn_ordinal_encoder(
             encoded_missing_value = np.array(
                 [int(ordinal_op.encoded_missing_value)]
             ).astype(np.int64)
-            attrs["values_int64s"] = np.concatenate(
-                (np.arange(len(categories) - 1).astype(np.int64), encoded_missing_value)
-            )
+
+            # handle max_categories or min_frequency
+            if default_to_infrequent_mappings is not None:
+                attrs["values_int64s"] = np.concatenate(
+                    (
+                        np.array(default_to_infrequent_mappings, dtype=np.int64),
+                        encoded_missing_value,
+                    )
+                )
+            else:
+                attrs["values_int64s"] = np.concatenate(
+                    (
+                        np.arange(len(categories) - 1).astype(np.int64),
+                        encoded_missing_value,
+                    )
+                )
         else:
-            attrs["values_int64s"] = np.arange(len(categories)).astype(np.int64)
+            # handle max_categories or min_frequency
+            if default_to_infrequent_mappings is not None:
+                attrs["values_int64s"] = np.array(
+                    default_to_infrequent_mappings, dtype=np.int64
+                )
+            else:
+                attrs["values_int64s"] = np.arange(len(categories)).astype(np.int64)
 
         if default_value:
             attrs["default_int64"] = default_value

tests/test_sklearn_ordinal_encoder.py

@@ -40,6 +40,11 @@ def set_output_support():
     return pv.Version(vers) >= pv.Version("1.2")
 
 
+def max_categories_support():
+    vers = ".".join(sklearn_version.split(".")[:2])
+    return pv.Version(vers) >= pv.Version("1.3")
+
+
 class TestSklearnOrdinalEncoderConverter(unittest.TestCase):
     @unittest.skipIf(
         not ordinal_encoder_support(),
@@ -379,6 +384,86 @@ def test_ordinal_encoder_pipeline_string_int64(self):
         )
         assert_almost_equal(expected, got[0].ravel())
 
+    @unittest.skipIf(
+        not max_categories_support(),
+        reason="OrdinalEncoder supports max_categories and min_frequencey since 1.3",
+    )
+    def test_model_ordinal_encoder_max_categories(self):
+        from onnxruntime import InferenceSession
+
+        model = OrdinalEncoder(max_categories=4)
+        data = np.array(
+            [["a"], ["b"], ["c"], ["d"], ["a"], ["b"], ["c"], ["e"]], dtype=np.object_
+        )
+
+        expected = model.fit_transform(data)
+
+        model_onnx = convert_sklearn(
+            model,
+            "scikit-learn ordinal encoder",
+            [("input", StringTensorType([None, 1]))],
+            target_opset=TARGET_OPSET,
+        )
+        self.assertIsNotNone(model_onnx)
+        dump_data_and_model(
+            data,
+            model,
+            model_onnx,
+            basename="SklearnOrdinalEncoderMaxCategories",
+        )
+
+        sess = InferenceSession(
+            model_onnx.SerializeToString(), providers=["CPUExecutionProvider"]
+        )
+        got = sess.run(
+            None,
+            {
+                "input": data,
+            },
+        )
+
+        assert_almost_equal(expected.reshape(-1), got[0].reshape(-1))
+
+    @unittest.skipIf(
+        not max_categories_support(),
+        reason="OrdinalEncoder supports max_categories and min_frequencey since 1.3",
+    )
+    def test_model_ordinal_encoder_min_frequency(self):
+        from onnxruntime import InferenceSession
+
+        model = OrdinalEncoder(min_frequency=2)
+        data = np.array(
+            [["a"], ["b"], ["c"], ["d"], ["a"], ["b"], ["c"], ["e"]], dtype=np.object_
+        )
+
+        expected = model.fit_transform(data)
+
+        model_onnx = convert_sklearn(
+            model,
+            "scikit-learn ordinal encoder",
+            [("input", StringTensorType([None, 1]))],
+            target_opset=TARGET_OPSET,
+        )
+        self.assertIsNotNone(model_onnx)
+        dump_data_and_model(
+            data,
+            model,
+            model_onnx,
+            basename="SklearnOrdinalEncoderMinFrequency",
+        )
+
+        sess = InferenceSession(
+            model_onnx.SerializeToString(), providers=["CPUExecutionProvider"]
+        )
+        got = sess.run(
+            None,
+            {
+                "input": data,
+            },
+        )
+
+        assert_almost_equal(expected.reshape(-1), got[0].reshape(-1))
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)