melite 0.2.2__tar.gz → 0.2.3__tar.gz

{melite-0.2.2 → melite-0.2.3}/.gitignore

@@ -19,3 +19,5 @@ site/
 .pytest_tmp
 
 dist/
+
+.tmp_stack_smoke/

{melite-0.2.2 → melite-0.2.3}/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [v0.2.3] - 2026-06-01
+
+### Added
+- Added opt-in experimental stacking via the `stack` model key in
+  `[models].active`.
+- Added sklearn `StackingClassifier` support using `stack_method="predict_proba"`,
+  `passthrough=False`, and `LogisticRegression` as the final estimator.
+- Added export and prediction coverage for saved stacking `.pkl` artifacts.
+
+### Changed
+- Standalone SVC remains a `StandardScaler` -> `SVC` pipeline.
+- The SVC base estimator inside stacking is also scaled and uses
+  `SVC(probability=True)` so stacking combines probability outputs.
+- Random Forest and XGBoost remain unscaled direct estimators because they are
+  tree-based models and do not require feature scaling by default.
+- Stacking-internal CV uses the configured split count and random state with
+  one repeat to satisfy sklearn's out-of-fold prediction requirements.
+
+### Notes
+- Stacking is experimental and disabled by default.
+- Export remains `.pkl` via `joblib`.
+- Optuna and MLflow are intentionally out of scope for v0.2.3.
+
+---
+
 ## [v0.2.2] - 2026-05-28
 
 ### Changed

{melite-0.2.2 → melite-0.2.3}/CITATION.cff

@@ -2,7 +2,7 @@ cff-version: 1.2.0
 message: "If you use this software, please cite it as below."
 type: software
 title: "MELITE: Multi-model Evaluation and Learning for Inference-ready Tabular Experiments"
-version: "0.2.2"
+version: "0.2.3"
 date-released: "2026-05-28"
 authors:
   - family-names: "Contreras-Torres"

{melite-0.2.2 → melite-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: melite
-Version: 0.2.2
+Version: 0.2.3
 Summary: Tabular classification benchmarking toolkit for model selection, repeated stratified cross-validation, final model export, and artifact-based inference.
 Project-URL: Homepage, https://github.com/NanoBiostructuresRG/melite
 Project-URL: Repository, https://github.com/NanoBiostructuresRG/melite
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 
 [![CI](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml/badge.svg)](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml)
 [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-v0.2.2-blue.svg)]()
+[![Version](https://img.shields.io/badge/version-v0.2.3-blue.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)]()
 
 **MELITE** is a pre-stable Python toolkit for tabular classification
@@ -60,7 +60,7 @@ Project: MELITE
 PyPI distribution: melite
 Import package: melite
 CLI: melite
-Version: 0.2.2
+Version: 0.2.3
 License: LGPL-3.0-or-later
 Status: alpha / pre-stable
 ```
@@ -133,7 +133,7 @@ print(result["probabilities"])
 | MELITE does | MELITE does not |
 |-------------|-----------------|
 | Accept prepared `X` and `y` arrays. | Generate fingerprints. |
-| Benchmark SVC, Random Forest, and XGBoost classifiers. | Process SMILES. |
+| Benchmark SVC, Random Forest, XGBoost, and opt-in experimental stacking classifiers. | Process SMILES. |
 | Select the best row by F1-macro. | Generate PCA or UMAP reductions from raw data. |
 | Export a final retrained `.pkl` model. | Act as a general AutoML framework. |
 | Run artifact-based inference through `predict()`. | Promise a stable 1.0 API yet. |
@@ -181,10 +181,19 @@ active = ["svc", "rf", "xgb"]
 ```
 
 Remove a key to skip that family during training. Valid keys are `svc`, `rf`,
-and `xgb`.
-
-SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn pipeline.
-Random Forest and XGBoost are trained as unscaled estimators.
+`xgb`, and experimental `stack`. Stacking is opt-in; add `"stack"` to
+`active` to evaluate an sklearn `StackingClassifier` alongside the default
+families.
+
+Standalone SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn
+pipeline because SVM/kernel-based methods are sensitive to feature scale.
+Random Forest and XGBoost are tree-based models and remain unscaled by
+default. Experimental stacking uses `stack_method="predict_proba"` with a
+scaled probabilistic SVC base estimator, unscaled RF/XGBoost base estimators,
+and a logistic regression final estimator. Its internal stacking CV uses the
+configured split count and random state with one repeat to satisfy sklearn's
+out-of-fold prediction requirements. Final exports remain `.pkl` artifacts
+serialized with `joblib`; Optuna and MLflow are not part of v0.2.3.
     
 ## CLI
 
@@ -248,7 +257,7 @@ Local inputs and generated artifacts such as `raw/`, `data/`, `output/`,
 
 ## Validation
 
-The current `dev/v0.2.2` branch targets:
+The current `dev/v0.2.3` branch targets:
 
 ```bash
 python -m pytest tests/ -v --basetemp=.review_pytest_tmp -o cache_dir=.review_pytest_cache

{melite-0.2.2 → melite-0.2.3}/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml/badge.svg)](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml)
 [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-v0.2.2-blue.svg)]()
+[![Version](https://img.shields.io/badge/version-v0.2.3-blue.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)]()
 
 **MELITE** is a pre-stable Python toolkit for tabular classification
@@ -21,7 +21,7 @@ Project: MELITE
 PyPI distribution: melite
 Import package: melite
 CLI: melite
-Version: 0.2.2
+Version: 0.2.3
 License: LGPL-3.0-or-later
 Status: alpha / pre-stable
 ```
@@ -94,7 +94,7 @@ print(result["probabilities"])
 | MELITE does | MELITE does not |
 |-------------|-----------------|
 | Accept prepared `X` and `y` arrays. | Generate fingerprints. |
-| Benchmark SVC, Random Forest, and XGBoost classifiers. | Process SMILES. |
+| Benchmark SVC, Random Forest, XGBoost, and opt-in experimental stacking classifiers. | Process SMILES. |
 | Select the best row by F1-macro. | Generate PCA or UMAP reductions from raw data. |
 | Export a final retrained `.pkl` model. | Act as a general AutoML framework. |
 | Run artifact-based inference through `predict()`. | Promise a stable 1.0 API yet. |
@@ -142,10 +142,19 @@ active = ["svc", "rf", "xgb"]
 ```
 
 Remove a key to skip that family during training. Valid keys are `svc`, `rf`,
-and `xgb`.
-
-SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn pipeline.
-Random Forest and XGBoost are trained as unscaled estimators.
+`xgb`, and experimental `stack`. Stacking is opt-in; add `"stack"` to
+`active` to evaluate an sklearn `StackingClassifier` alongside the default
+families.
+
+Standalone SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn
+pipeline because SVM/kernel-based methods are sensitive to feature scale.
+Random Forest and XGBoost are tree-based models and remain unscaled by
+default. Experimental stacking uses `stack_method="predict_proba"` with a
+scaled probabilistic SVC base estimator, unscaled RF/XGBoost base estimators,
+and a logistic regression final estimator. Its internal stacking CV uses the
+configured split count and random state with one repeat to satisfy sklearn's
+out-of-fold prediction requirements. Final exports remain `.pkl` artifacts
+serialized with `joblib`; Optuna and MLflow are not part of v0.2.3.
     
 ## CLI
 
@@ -209,7 +218,7 @@ Local inputs and generated artifacts such as `raw/`, `data/`, `output/`,
 
 ## Validation
 
-The current `dev/v0.2.2` branch targets:
+The current `dev/v0.2.3` branch targets:
 
 ```bash
 python -m pytest tests/ -v --basetemp=.review_pytest_tmp -o cache_dir=.review_pytest_cache

{melite-0.2.2 → melite-0.2.3}/melite/config.py

@@ -76,7 +76,8 @@ class Config:
         Normalized dataset registry keyed by user-defined dataset id. Each
         entry contains ``path``, ``label_path``, and ``metadata`` keys.
     ACTIVE_MODELS : list of str
-        Model keys to include in the benchmark (e.g. ``["svc", "rf", "xgb"]``).
+        Model keys to include in the benchmark (e.g. ``["svc", "rf", "xgb"]``;
+        add ``"stack"`` to opt in to experimental stacking).
     CV_CONFIG : dict
         Cross-validation settings with keys ``n_splits``, ``n_repeats``, and
         ``random_state``.
@@ -84,7 +85,7 @@ class Config:
         Raw hyperparameter grid definitions, one entry per model configuration.
     PARAM_GRID_BY_MODEL : dict
         Compiled :class:`~sklearn.model_selection.ParameterGrid` objects keyed
-        by model name (``"svc"``, ``"rf"``, ``"xgb"``).
+        by model name (``"svc"``, ``"rf"``, ``"xgb"``, ``"stack"``).
 
     Examples
     --------
@@ -219,6 +220,9 @@ class Config:
                     "reg_alpha": [0],
                     "reg_lambda": [1],
                 },
+                {
+                    "model": ["stack"],
+                },
             ]
         return [
             {
@@ -259,6 +263,9 @@ class Config:
                 "reg_alpha": [0, 0.5],
                 "reg_lambda": [1, 2],
             },
+            {
+                "model": ["stack"],
+            },
         ]
 
     def _group_param_grid_by_model(self) -> dict:
@@ -291,7 +298,7 @@ class Config:
         Parameters
         ----------
         model : str
-            Model key. One of ``"svc"``, ``"rf"``, or ``"xgb"``.
+            Model key. One of ``"svc"``, ``"rf"``, ``"xgb"``, or ``"stack"``.
 
         Returns
         -------

{melite-0.2.2 → melite-0.2.3}/melite/config_default.toml

@@ -21,5 +21,5 @@ n_splits = 3
 n_repeats = 1
 
 [models]
-# Active models to benchmark. Remove any entry to skip that model.
+# Active models to benchmark. Add "stack" to opt in to experimental stacking.
 active = ["svc", "rf", "xgb"]

{melite-0.2.2 → melite-0.2.3}/melite/export_best_model.py

@@ -22,7 +22,8 @@ import pandas as pd
 from .config import Config
 from .load_dataset import load_datasets, _load_one_dataset
 from .plot_metrics import plot_cv_distributions
-from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from sklearn.linear_model import LogisticRegression
 from sklearn.model_selection import cross_validate, RepeatedStratifiedKFold
 from sklearn.pipeline import Pipeline as SklearnPipeline
 from sklearn.preprocessing import StandardScaler
@@ -52,6 +53,49 @@ def _safe_filename_part(value: Any) -> str:
     return re.sub(r"[^A-Za-z0-9_.-]+", "_", str(value).strip()).strip("_")
 
 
+def _build_cv_strategy(cv_config: dict | None):
+    if cv_config is None:
+        cv_config = {"n_splits": 10, "n_repeats": 5, "random_state": 42}
+    # StackingClassifier uses cross_val_predict internally, which requires
+    # one partition of the data rather than repeated test assignments.
+    return RepeatedStratifiedKFold(
+        n_splits=cv_config["n_splits"],
+        n_repeats=1,
+        random_state=cv_config["random_state"],
+    )
+
+
+def _build_stacking_classifier(
+    random_state: int = 42,
+    cv_config: dict | None = None,
+) -> StackingClassifier:
+    return StackingClassifier(
+        estimators=[
+            ("svc", SklearnPipeline([
+                ("scaler", StandardScaler()),
+                ("svc", SVC(probability=True, random_state=random_state)),
+            ])),
+            ("rf", RandomForestClassifier(random_state=random_state, n_jobs=-1)),
+            (
+                "xgb",
+                XGBClassifier(
+                    eval_metric="logloss",
+                    random_state=random_state,
+                    n_jobs=-1,
+                ),
+            ),
+        ],
+        final_estimator=LogisticRegression(
+            random_state=random_state,
+            max_iter=1000,
+        ),
+        cv=_build_cv_strategy(cv_config),
+        stack_method="predict_proba",
+        passthrough=False,
+        n_jobs=-1,
+    )
+
+
 class DatasetLoader:
     """Load feature matrices and labels for model retraining.
 
@@ -290,7 +334,12 @@ class Finalizer:
         row = self._get_selected_row()
         self._check_smoke_guard(row)
         X, y = self._loader.load_row(row)
-        model = self._build_model(row.model_name, row.parameters)
+        model = self._build_model(
+            row.model_name,
+            row.parameters,
+            cv_config=self._cfg.get_cv_config(),
+            random_state=getattr(self._cfg, "RANDOM_STATE", 42),
+        )
 
         figures_dir = Path(self._cfg.PATHS["OUTPUT"]) / "figures"
         self._cv_and_plot(model, X, y, row, figures_dir)
@@ -330,7 +379,12 @@ class Finalizer:
             print("[ERR] Invalid row number; please try again.")
 
     @staticmethod
-    def _build_model(name: str, serialised_params: str) -> Any:
+    def _build_model(
+        name: str,
+        serialised_params: str,
+        cv_config: dict | None = None,
+        random_state: int = 42,
+    ) -> Any:
         params = ast.literal_eval(serialised_params)
         if name == "SVC":
             model = SklearnPipeline([
@@ -343,6 +397,12 @@ class Finalizer:
             }
             svc_params.setdefault("svc__probability", True)
             return model.set_params(**svc_params)
+        if name == "StackingClassifier":
+            model = _build_stacking_classifier(
+                random_state=random_state,
+                cv_config=cv_config,
+            )
+            return model.set_params(**params)
         try:
             return MODEL_MAP[name](**params)
         except KeyError as exc:

{melite-0.2.2 → melite-0.2.3}/melite/model_training.py

@@ -11,7 +11,8 @@ cross-validation.
 from abc import ABC, abstractmethod
 
 import numpy as np
-from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from sklearn.linear_model import LogisticRegression
 from sklearn.model_selection import GridSearchCV, RepeatedStratifiedKFold, cross_validate
 from sklearn.pipeline import Pipeline as SklearnPipeline
 from sklearn.preprocessing import StandardScaler
@@ -90,9 +91,45 @@ class MultiModelTrainer(ModelTrainer):
             ]),
             "rf": lambda: RandomForestClassifier(random_state=rs, n_jobs=-1),
             "xgb": lambda: XGBClassifier(eval_metric="logloss", random_state=rs, n_jobs=-1),
+            "stack": lambda: self._build_stacking_classifier(rs),
         }
         self.active_models = self._validate_active_models()
 
+    def _build_stacking_classifier(self, random_state):
+        cv = self._build_cv_strategy()
+        # StackingClassifier uses cross_val_predict internally, which requires
+        # one partition of the data rather than repeated test assignments.
+        stacking_cv = RepeatedStratifiedKFold(
+            n_splits=cv.cvargs["n_splits"],
+            n_repeats=1,
+            random_state=cv.random_state,
+        )
+        return StackingClassifier(
+            estimators=[
+                ("svc", SklearnPipeline([
+                    ("scaler", StandardScaler()),
+                    ("svc", SVC(probability=True, random_state=random_state)),
+                ])),
+                ("rf", RandomForestClassifier(random_state=random_state, n_jobs=-1)),
+                (
+                    "xgb",
+                    XGBClassifier(
+                        eval_metric="logloss",
+                        random_state=random_state,
+                        n_jobs=-1,
+                    ),
+                ),
+            ],
+            final_estimator=LogisticRegression(
+                random_state=random_state,
+                max_iter=1000,
+            ),
+            cv=stacking_cv,
+            stack_method="predict_proba",
+            passthrough=False,
+            n_jobs=-1,
+        )
+
     def _validate_active_models(self):
         active_models = getattr(self.config, "ACTIVE_MODELS", list(self.model_builders))
         if not active_models:

{melite-0.2.2 → melite-0.2.3}/melite/version.py

@@ -6,7 +6,7 @@ It is read by ``hatchling`` at build time via ``[tool.hatch.version]``
 and imported by ``result_manager`` to stamp generated reports.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 PROJECT_NAME = "MELITE"
 PROJECT_VERSION = __version__
 PROJECT_STATUS = "alpha"

{melite-0.2.2 → melite-0.2.3}/tests/test_export.py

@@ -9,9 +9,11 @@ import pytest
 
 from melite.config import Config
 from melite.export_best_model import Finalizer
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
 from sklearn.pipeline import Pipeline as SklearnPipeline
 from sklearn.preprocessing import StandardScaler
 from sklearn.svm import SVC
+from xgboost import XGBClassifier
 
 
 class DummyModel:
@@ -156,7 +158,9 @@ def test_export_dataset_row_uses_dataset_id_for_artifact(monkeypatch, tmp_path):
             "smoke": False,
         },
     )
-    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(
+        Finalizer, "_build_model", staticmethod(lambda *_, **__: DummyModel())
+    )
     monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
 
     Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
@@ -200,7 +204,9 @@ def test_export_dataset_row_uses_strict_load_datasets(monkeypatch, tmp_path):
         }
 
     monkeypatch.setattr(export_module, "load_datasets", fake_load_datasets)
-    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(
+        Finalizer, "_build_model", staticmethod(lambda *_, **__: DummyModel())
+    )
     monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
 
     Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
@@ -231,7 +237,9 @@ def test_export_dataset_npz_without_X_fails_clearly(monkeypatch, tmp_path):
             "smoke": False,
         },
     )
-    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(
+        Finalizer, "_build_model", staticmethod(lambda *_, **__: DummyModel())
+    )
     monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
 
     with pytest.raises(ValueError, match="Required key 'X' not found"):
@@ -260,7 +268,9 @@ def test_export_legacy_row_with_valid_X_and_labels_succeeds(monkeypatch, tmp_pat
             "smoke": False,
         },
     )
-    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(
+        Finalizer, "_build_model", staticmethod(lambda *_, **__: DummyModel())
+    )
     monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
 
     Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
@@ -310,6 +320,69 @@ def test_export_svc_accepts_legacy_unprefixed_parameters():
     assert model.named_steps["svc"].C == 1
 
 
+def test_export_builds_stacking_classifier_with_expected_contract():
+    cv_config = {"n_splits": 2, "n_repeats": 1, "random_state": 42}
+
+    model = Finalizer._build_model(
+        "StackingClassifier",
+        "{}",
+        cv_config=cv_config,
+        random_state=42,
+    )
+    estimators = dict(model.estimators)
+    svc = estimators["svc"]
+    rf = estimators["rf"]
+    xgb = estimators["xgb"]
+
+    assert isinstance(model, StackingClassifier)
+    assert model.stack_method == "predict_proba"
+    assert model.passthrough is False
+    assert model.cv.cvargs["n_splits"] == 2
+    assert model.cv.n_repeats == 1
+    assert model.cv.random_state == 42
+    assert isinstance(svc, SklearnPipeline)
+    assert list(svc.named_steps) == ["scaler", "svc"]
+    assert isinstance(svc.named_steps["scaler"], StandardScaler)
+    assert isinstance(svc.named_steps["svc"], SVC)
+    assert svc.named_steps["svc"].probability is True
+    assert isinstance(rf, RandomForestClassifier)
+    assert isinstance(xgb, XGBClassifier)
+    assert not isinstance(rf, SklearnPipeline)
+    assert not isinstance(xgb, SklearnPipeline)
+
+
+def test_export_can_rebuild_and_save_stacking_model(monkeypatch, tmp_path):
+    label_path, y = _write_labels(tmp_path)
+    dataset_path = _write_npz(tmp_path, "toy", np.ones((20, 5)), y)
+    cfg = _make_config(tmp_path)
+    cfg.CV_CONFIG = {"n_splits": 2, "n_repeats": 1, "random_state": 42}
+    cfg.DATASETS = {
+        "toy": {
+            "path": str(dataset_path),
+            "label_path": str(label_path),
+            "metadata": {"family": "smoke", "method": "toy"},
+        }
+    }
+    csv_path = tmp_path / "output" / "results.csv"
+    _write_results_csv(
+        csv_path,
+        ["dataset", "model_name", "parameters", "smoke"],
+        {
+            "dataset": "toy",
+            "model_name": "StackingClassifier",
+            "parameters": "{'rf__n_estimators': 2, 'xgb__n_estimators': 2}",
+            "smoke": False,
+        },
+    )
+    monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
+
+    Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
+
+    model = joblib.load(tmp_path / "output" / "Model_StackingClassifier_toy.pkl")
+    assert isinstance(model, StackingClassifier)
+    assert model.stack_method == "predict_proba"
+
+
 def test_export_legacy_npz_without_X_does_not_fallback_to_first_key(
     monkeypatch, tmp_path
 ):
@@ -334,7 +407,9 @@ def test_export_legacy_npz_without_X_does_not_fallback_to_first_key(
             "smoke": False,
         },
     )
-    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(
+        Finalizer, "_build_model", staticmethod(lambda *_, **__: DummyModel())
+    )
     monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
 
     with pytest.raises(ValueError, match="Required key 'X' not found"):

{melite-0.2.2 → melite-0.2.3}/tests/test_model_training.py

@@ -7,11 +7,14 @@ import numpy as np
 import pytest
 
 from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import StackingClassifier
+from sklearn.model_selection import RepeatedStratifiedKFold
 from sklearn.pipeline import Pipeline as SklearnPipeline
 from sklearn.preprocessing import StandardScaler
 from sklearn.svm import SVC
 from xgboost import XGBClassifier
 
+import melite.model_training as model_training
 from melite.model_training import MultiModelTrainer
 
 
@@ -23,6 +26,7 @@ def _config(active_models):
             {"model": ["svc"], "svc__C": [1], "svc__kernel": ["linear"]},
             {"model": ["rf"], "n_estimators": [10]},
             {"model": ["xgb"], "n_estimators": [10]},
+            {"model": ["stack"]},
         ],
         get_cv_config=lambda: {
             "n_splits": 2,
@@ -38,6 +42,7 @@ def _trainer_with_fake_training(active_models):
         "svc": lambda: "svc-estimator",
         "rf": lambda: "rf-estimator",
         "xgb": lambda: "xgb-estimator",
+        "stack": lambda: "stack-estimator",
     }
     calls = []
 
@@ -110,6 +115,40 @@ def test_rf_and_xgb_builders_remain_unscaled_direct_estimators():
     assert not isinstance(xgb, SklearnPipeline)
 
 
+def test_stacking_builder_returns_experimental_stacking_classifier():
+    trainer = MultiModelTrainer(_config(["stack"]))
+
+    model = trainer.model_builders["stack"]()
+    estimators = dict(model.estimators)
+    svc = estimators["svc"]
+    rf = estimators["rf"]
+    xgb = estimators["xgb"]
+
+    assert isinstance(model, StackingClassifier)
+    assert model.stack_method == "predict_proba"
+    assert model.passthrough is False
+    assert isinstance(svc, SklearnPipeline)
+    assert list(svc.named_steps) == ["scaler", "svc"]
+    assert isinstance(svc.named_steps["scaler"], StandardScaler)
+    assert isinstance(svc.named_steps["svc"], SVC)
+    assert svc.named_steps["svc"].probability is True
+    assert isinstance(rf, RandomForestClassifier)
+    assert isinstance(xgb, XGBClassifier)
+    assert not isinstance(rf, SklearnPipeline)
+    assert not isinstance(xgb, SklearnPipeline)
+
+
+def test_stacking_builder_reuses_repeated_stratified_cv_strategy():
+    trainer = MultiModelTrainer(_config(["stack"]))
+
+    model = trainer.model_builders["stack"]()
+
+    assert isinstance(model.cv, RepeatedStratifiedKFold)
+    assert model.cv.cvargs["n_splits"] == 2
+    assert model.cv.n_repeats == 1
+    assert model.cv.random_state == 42
+
+
 def test_filter_param_grid_preserves_svc_pipeline_prefixes():
     trainer = MultiModelTrainer(_config(["svc"]))
 
@@ -118,6 +157,48 @@ def test_filter_param_grid_preserves_svc_pipeline_prefixes():
     assert grid == [{"svc__C": [1], "svc__kernel": ["linear"]}]
 
 
+def test_filter_param_grid_supports_minimal_stack_grid():
+    trainer = MultiModelTrainer(_config(["stack"]))
+
+    grid = trainer._filter_param_grid("stack")
+
+    assert grid == [{}]
+
+
+def test_grid_search_uses_f1_macro_scoring(monkeypatch):
+    captured = {}
+
+    class DummyGridSearchCV:
+        def __init__(self, model, param_grid, scoring, cv, n_jobs):
+            captured.update({
+                "model": model,
+                "param_grid": param_grid,
+                "scoring": scoring,
+                "cv": cv,
+                "n_jobs": n_jobs,
+            })
+            self.best_estimator_ = "best-estimator"
+            self.best_params_ = {"best": True}
+
+        def fit(self, X_train, y_train):
+            captured["fit_shape"] = X_train.shape
+
+    monkeypatch.setattr(model_training, "GridSearchCV", DummyGridSearchCV)
+    trainer = MultiModelTrainer(_config(["svc"]))
+
+    estimator, params = trainer.perform_grid_search(
+        "estimator",
+        np.ones((4, 2)),
+        np.array([0, 1, 0, 1]),
+        [{"param": [1]}],
+    )
+
+    assert captured["scoring"] == "f1_macro"
+    assert isinstance(captured["cv"], RepeatedStratifiedKFold)
+    assert estimator == "best-estimator"
+    assert params == {"best": True}
+
+
 def test_invalid_active_model_raises_clear_error():
     with pytest.raises(ValueError, match="Unknown active model\\(s\\): knn"):
         MultiModelTrainer(_config(["svc", "knn"]))

{melite-0.2.2 → melite-0.2.3}/tests/test_predict.py

@@ -4,6 +4,7 @@
 import numpy as np
 import pytest
 import joblib
+from melite.export_best_model import Finalizer
 from melite.predict import predict
 from sklearn.pipeline import Pipeline as SklearnPipeline
 from sklearn.preprocessing import StandardScaler
@@ -94,3 +95,22 @@ def test_predict_loads_exported_svc_pipeline(tmp_path):
 
     assert result["predictions"].shape == (4,)
     assert result["probabilities"].shape == (4, 2)
+
+
+def test_predict_loads_exported_stacking_classifier(tmp_path):
+    X_train = np.random.rand(20, 5).astype(np.float32)
+    y_train = np.array([0, 1] * 10, dtype=np.int64)
+    model = Finalizer._build_model(
+        "StackingClassifier",
+        "{'rf__n_estimators': 2, 'xgb__n_estimators': 2}",
+        cv_config={"n_splits": 2, "n_repeats": 1, "random_state": 42},
+        random_state=42,
+    )
+    model.fit(X_train, y_train)
+    model_path = tmp_path / "Model_StackingClassifier_toy.pkl"
+    joblib.dump(model, model_path)
+
+    result = predict(model_path, np.random.rand(4, 5).astype(np.float32))
+
+    assert result["predictions"].shape == (4,)
+    assert result["probabilities"].shape == (4, 2)