Fix missing input dimension in StackClassifier with ColumnTransformer (#1201)

* Fix missing input dimension in StackClassifier with ColumnTransformer

Signed-off-by: xadupre <[email protected]>

* changelogs

Signed-off-by: xadupre <[email protected]>

---------

Signed-off-by: xadupre <[email protected]>

Author: xadupre

CHANGELOGS.md

@@ -2,6 +2,8 @@
 
 ## 1.20.0
 
+* Fixes missing dimension (number of features) in StackingClassifier
+  [#1201](https://github.com/onnx/sklearn-onnx/issues/1201)
 * Fixes CastTransformer output type
   [#1200](https://github.com/onnx/sklearn-onnx/issues/1200)
 * Fixes unknown_value=np.nan in OrdinalEncoder

skl2onnx/common/utils.py

@@ -91,6 +91,9 @@ def get_column_index(i, inputs):
             return 0, 0
         vi = 0
         pos = 0
+        assert (
+            len(inputs[0].type.shape) == 2
+        ), f"Unexpect rank={len(inputs[0].type.shape)} for inputs={inputs}, i={i}"
         end = inputs[0].type.shape[1] if isinstance(inputs[0].type, TensorType) else 1
         if end is None:
             raise RuntimeError(

skl2onnx/operator_converters/stacking.py

@@ -137,7 +137,10 @@ def convert_sklearn_stacking_classifier(
 
     merged_proba_tensor = _transform(scope, operator, container, stacking_op)
     merge_proba = scope.declare_local_variable(
-        "stack_merge_proba", operator.inputs[0].type.__class__()
+        "stack_merge_proba",
+        operator.inputs[0].type.__class__(
+            [None, stacking_op.final_estimator_.n_features_in_]
+        ),
     )
     container.add_node("Identity", [merged_proba_tensor], [merge_proba.onnx_name])
     prob = _fetch_scores(

tests/test_sklearn_stacking.py

@@ -564,6 +564,104 @@ def converter(scope, operator, container):
         got = sess.run(None, {"X": x})[0]
         self.assertEqual(got.shape[0], x.shape[0])
 
+    def test_model_stacking_classifier_column_transformer_issue_1199(self):
+        # see https://github.com/onnx/sklearn-onnx/issues/1199
+        import random
+
+        import numpy as np
+        from skl2onnx import to_onnx
+        from sklearn.compose import ColumnTransformer
+        from sklearn.datasets import make_classification
+        from sklearn.ensemble import StackingClassifier, RandomForestClassifier
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.model_selection import train_test_split
+        from sklearn.pipeline import Pipeline
+        from sklearn.preprocessing import StandardScaler
+
+        np.random.seed(42)
+        random.seed(42)
+
+        X, y = make_classification(n_samples=1000, n_features=5, random_state=42)
+
+        pipeline = Pipeline(
+            steps=[
+                (
+                    "stacking_classifier",
+                    StackingClassifier(
+                        estimators=[
+                            (
+                                "tree",
+                                Pipeline(
+                                    [
+                                        (
+                                            "tree_column_selector",
+                                            ColumnTransformer(
+                                                [
+                                                    (
+                                                        "tree_cols",
+                                                        "passthrough",
+                                                        [0, 1, 2],
+                                                    )
+                                                ],
+                                                remainder="drop",
+                                            ),
+                                        ),
+                                        ("tree_classifier", RandomForestClassifier()),
+                                    ]
+                                ),
+                            )
+                        ],
+                        final_estimator=Pipeline(
+                            [
+                                (
+                                    "feature_combiner",
+                                    ColumnTransformer(
+                                        [
+                                            (
+                                                "standardize_proba",
+                                                Pipeline(
+                                                    [
+                                                        (
+                                                            "logit_transform",
+                                                            StandardScaler(),
+                                                        )
+                                                    ]
+                                                ),
+                                                [0],
+                                            ),
+                                            ("other_features", "passthrough", [4, 5]),
+                                        ],
+                                        remainder="drop",
+                                    ),
+                                ),
+                                ("final_logistic", LogisticRegression()),
+                            ]
+                        ),
+                        cv=2,
+                        stack_method="auto",
+                        passthrough=True,
+                    ),
+                )
+            ]
+        )
+
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=4
+        )
+        pipeline.fit(X_train, y_train)
+        expected = pipeline.predict_proba(X_train)
+        model_onnx = to_onnx(
+            pipeline,
+            X_train[:1].astype(np.float32),
+            verbose=1,
+            options={"zipmap": False},
+        )
+        sess = InferenceSession(
+            model_onnx.SerializeToString(), providers=["CPUExecutionProvider"]
+        )
+        got = sess.run(None, {"X": X_train.astype(np.float32)})
+        assert_almost_equal(expected, got[1], decimal=5)
+
 
 if __name__ == "__main__":
     # import logging