julearn 0.3.4.dev19__tar.gz → 0.3.4.dev34__tar.gz

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: julearn
-Version: 0.3.4.dev19
+Version: 0.3.4.dev34
 Summary: Juelich Machine Learning Library
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Sami Hamdan <s.hamdan@fz-juelich.de>
 Maintainer-email: Sami Hamdan <s.hamdan@fz-juelich.de>

julearn-0.3.4.dev34/docs/changes/newsfragments/274.enh

@@ -0,0 +1 @@
+Optimise wrapping of steps and models in the pipeline only when a subset of features is being used, by `Fede Raimondo`_

julearn-0.3.4.dev34/docs/changes/newsfragments/293.enh

@@ -0,0 +1 @@
+Change the internal logic of :func:`.run_cross_validation` to optimise joblib calls by `Fede Raimondo`_

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/docs/configuration.rst

@@ -47,3 +47,10 @@ Here you can find the comprehensive list of flags that can be set:
      - | Disable printing the list of expanded column names in ``X_types``.
        | If set to ``True``, the list of types of X will not be printed.
      - The user will not see the expanded ``X_types`` column names.
+   * - ``enable_parallel_column_transformers``
+     - | This flag enables parallel execution of column transformers by
+       | reverting to the default behaviour of scikit-learn
+       | (instead of using ``n_jobs=1``)
+       | If set to ``True``, the parameter will be set back to None.
+     - | Column transformers will be applied in parallel, using more resources.
+       | than expected.

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/examples/02_inspection/plot_preprocess.py

@@ -121,7 +121,7 @@ X_after_zscore = preprocess(model, X=X, data=df, until="zscore")
 fig, axes = plt.subplots(1, 2, figsize=(12, 6))
 sns.scatterplot(x=X[0], y=X[1], data=df, ax=axes[0])
 axes[0].set_title("Raw features")
-sns.scatterplot(x="pca__pca0", y="pca__pca1", data=X_after_pca, ax=axes[1])
+sns.scatterplot(x="pca0", y="pca1", data=X_after_pca, ax=axes[1])
 axes[1].set_title("PCA components")
 
 ###############################################################################

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/examples/02_inspection/run_binary_inspect_folds.py

@@ -44,7 +44,6 @@ creator = PipelineCreator(problem_type="classification")
 creator.add("zscore")
 creator.add("svm")
 
-cv = ShuffleSplit(n_splits=5, train_size=0.7, random_state=200)
 cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=4, random_state=200)
 
 scores, model, inspector = run_cross_validation(

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/examples/04_confounds/run_return_confounds.py

@@ -172,4 +172,4 @@ scores
 # (including confounds and categorical variables).
 # Here we can see that the model is using 10 features (9 deconfounded features
 # and the confound).
-print(len(model.steps[-1][1].model.coef_))
+print(len(model.steps[-1][1].coef_))

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/examples/99_docs/run_model_inspection_docs.py

@@ -140,7 +140,7 @@ c_values = []
 for fold_inspector in inspector.folds:
     fold_model = fold_inspector.model
     c_values.append(
-        fold_model.get_fitted_params()["svm__model_"].get_params()["C"]
+        fold_model.get_fitted_params()["svm__C"]
     )
 
 ##############################################################################

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.4.dev19'
-__version_tuple__ = version_tuple = (0, 3, 4, 'dev19')
+__version__ = version = '0.3.4.dev34'
+__version_tuple__ = version_tuple = (0, 3, 4, 'dev34')

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/api.py

@@ -11,13 +11,13 @@ import pandas as pd
 import sklearn
 from sklearn.base import BaseEstimator
 from sklearn.model_selection import (
-    check_cv,
     cross_validate,
 )
 from sklearn.model_selection._search import BaseSearchCV
 from sklearn.pipeline import Pipeline
 
 from .inspect import Inspector
+from .model_selection.utils import check_cv
 from .pipeline import PipelineCreator
 from .pipeline.merger import merge_pipelines
 from .prepare import check_consistency, prepare_input_data
@@ -541,16 +541,19 @@ def run_cross_validation(
         seed=seed,
     )
 
+    include_final_model = return_estimator in ["final", "all"]
+    cv_return_estimator = return_estimator in ["cv", "all", "final"]
+
     # Prepare cross validation
     cv_outer = check_cv(
         cv,  # type: ignore
         classifier=problem_type == "classification",
+        include_final_model=include_final_model,
     )
     logger.info(f"Using outer CV scheme {cv_outer}")
 
     check_consistency(df_y, cv, groups, problem_type)  # type: ignore
 
-    cv_return_estimator = return_estimator in ["cv", "all"]
     scoring = check_scoring(
         pipeline,  # type: ignore
         scoring,
@@ -583,18 +586,28 @@ def run_cross_validation(
         **_sklearn_deprec_fit_params,
     )
 
-    n_repeats = getattr(cv_outer, "n_repeats", 1)
-    n_folds = len(scores["fit_time"]) // n_repeats
-
-    repeats = np.repeat(np.arange(n_repeats), n_folds)
-    folds = np.tile(np.arange(n_folds), n_repeats)
-
     fold_sizes = np.array(
         [
             list(map(len, x))
             for x in cv_outer.split(df_X, df_y, groups=df_groups)
         ]
     )
+
+    if include_final_model:
+        # If we include the final model, we need to remove the last item in
+        # the scores as this is the final model
+        pipeline = scores["estimator"][-1]
+        if return_estimator == "final":
+            scores.pop("estimator")
+        scores = {k: v[:-1] for k, v in scores.items()}
+        fold_sizes = fold_sizes[:-1]
+
+    n_repeats = getattr(cv_outer, "n_repeats", 1)
+    n_folds = len(scores["fit_time"]) // n_repeats
+
+    repeats = np.repeat(np.arange(n_repeats), n_folds)
+    folds = np.tile(np.arange(n_folds), n_repeats)
+
     scores["n_train"] = fold_sizes[:, 0]
     scores["n_test"] = fold_sizes[:, 1]
     scores["repeat"] = repeats
@@ -602,11 +615,10 @@ def run_cross_validation(
     scores["cv_mdsum"] = cv_mdsum
 
     scores_df = pd.DataFrame(scores)
+
     out = scores_df
-    if return_estimator in ["final", "all"]:
-        logger.info("Fitting final model")
-        pipeline.fit(df_X, df_y, **fit_params)
-        out = scores_df, pipeline
+    if include_final_model:
+        out = out, pipeline
 
     if return_inspector:
         inspector = Inspector(
@@ -615,7 +627,7 @@ def run_cross_validation(
             X=df_X,
             y=df_y,
             groups=df_groups,
-            cv=cv_outer,
+            cv=cv_outer.cv if include_final_model else cv_outer,
         )
         if isinstance(out, tuple):
             out = (*out, inspector)

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/config.py

@@ -14,6 +14,7 @@ _global_config["disable_x_check"] = False
 _global_config["disable_xtypes_check"] = False
 _global_config["disable_x_verbose"] = False
 _global_config["disable_xtypes_verbose"] = False
+_global_config["enable_parallel_column_transformers"] = False
 
 
 def set_config(key: str, value: Any) -> None:

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/inspect/_pipeline.py

@@ -63,11 +63,14 @@ class _EstimatorInspector:
                 ),
             }
 
-        return {
+        private_params = {
             param: val
             for param, val in all_params.items()
             if re.match(r"^[a-zA-Z].*[a-zA-Z0-9]*_$", param)
         }
+        out = self.get_params()
+        out.update(private_params)
+        return out
 
     @property
     def estimator(self):

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/inspect/tests/test_pipeline.py

@@ -152,14 +152,25 @@ def test_steps(
 @pytest.mark.parametrize(
     "est,fitted_params",
     [
-        [MockTestEst(), {"param_0_": 0, "param_1_": 1}],
+        [
+            MockTestEst(),
+            {"hype_0": 0, "hype_1": 1, "param_0_": 0, "param_1_": 1},
+        ],
         [
             JuColumnTransformer(
                 "test",
                 MockTestEst(),  # type: ignore
                 "continuous",
             ),
-            {"param_0_": 0, "param_1_": 1},
+            {
+                "hype_0": 0,
+                "hype_1": 1,
+                "param_0_": 0,
+                "param_1_": 1,
+                "needed_types": None,
+                "row_select_col_type": None,
+                "row_select_vals": None,
+            },
         ],
     ],
 )
@@ -183,6 +194,9 @@ def test_inspect_estimator(
     assert est.get_params() == inspector.get_params()
     inspect_params = inspector.get_fitted_params()
     inspect_params.pop("column_transformer_", None)
+    inspect_params.pop("apply_to", None)
+    inspect_params.pop("transformer", None)
+    inspect_params.pop("name", None)
     assert fitted_params == inspect_params
 
 
@@ -196,8 +210,14 @@ def test_inspect_pipeline(df_iris: "pd.DataFrame") -> None:
 
     """
     expected_fitted_params = {
+        "jucolumntransformer__hype_0": 0,
+        "jucolumntransformer__hype_1": 1,
         "jucolumntransformer__param_0_": 0,
         "jucolumntransformer__param_1_": 1,
+        "jucolumntransformer__needed_types": None,
+        "jucolumntransformer__row_select_col_type": None,
+        "jucolumntransformer__row_select_vals": None,
+        "jucolumntransformer__name": "test",
     }
 
     pipe = (
@@ -216,6 +236,8 @@ def test_inspect_pipeline(df_iris: "pd.DataFrame") -> None:
     inspector = PipelineInspector(pipe)
     inspect_params = inspector.get_fitted_params()
     inspect_params.pop("jucolumntransformer__column_transformer_", None)
+    inspect_params.pop("jucolumntransformer__transformer", None)
+    inspect_params.pop("jucolumntransformer__apply_to", None)
     inspect_params = {
         key: val
         for key, val in inspect_params.items()

julearn-0.3.4.dev34/julearn/model_selection/final_model_cv.py

@@ -0,0 +1,96 @@
+"""CV Wrapper that includes a fold with all the data."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from typing import TYPE_CHECKING, Generator, Optional, Tuple
+
+import numpy as np
+
+
+if TYPE_CHECKING:
+    from sklearn.model_selection import BaseCrossValidator
+
+
+class _JulearnFinalModelCV:
+    """Final model cross-validation iterator.
+
+    Wraps any CV iterator to provide an extra iteration with the full dataset.
+
+    Parameters
+    ----------
+    cv : BaseCrossValidator
+        The cross-validation iterator to wrap.
+
+    """
+
+    def __init__(self, cv: "BaseCrossValidator") -> None:
+        self.cv = cv
+        if hasattr(cv, "n_repeats"):
+            self.n_repeats = cv.n_repeats
+
+    def split(
+        self,
+        X: np.ndarray,  # noqa: N803
+        y: np.ndarray,
+        groups: Optional[np.ndarray] = None,
+    ) -> Generator[Tuple[np.ndarray, np.ndarray], None, None]:
+        """Generate indices to split data into training and test set.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where n_samples is the number of samples
+            and n_features is the number of features.
+            Note that providing ``y`` is sufficient to generate the splits and
+            hence ``np.zeros(n_samples)`` may be used as a placeholder for
+            ``X`` instead of actual training data.
+
+        y : array-like of shape (n_samples,), default=None
+            The target variable for supervised learning problems.
+
+        groups : array-like of shape (n_samples,), default=None
+            Group labels for the samples used while splitting the dataset into
+            train/test set.
+
+        Yields
+        ------
+        train : ndarray
+            The training set indices for that split.
+        test : ndarray
+            The testing set indices for that split.
+
+        Notes
+        -----
+        This CV Splitter will generate an extra fold where the full dataset is
+        used for training and testing. This is useful to train the final model
+        on the full dataset at the same time as the cross-validation,
+        profitting for joblib calls.
+
+        """
+        yield from self.cv.split(X, y, groups)
+        all_inds = np.arange(len(X))
+        # For the last fold, train on all samples and return only 2 for testing
+        yield all_inds, all_inds[:2]
+
+    def get_n_splits(self) -> int:
+        """Get the number of splits.
+
+        Returns
+        -------
+        int
+            The number of splits.
+
+        """
+        return self.cv.get_n_splits() + 1
+
+    def __repr__(self) -> str:
+        """Return the representation of the object.
+
+        Returns
+        -------
+        str
+            The representation of the object.
+
+        """
+        return f"{self.cv} (incl. final model)"

julearn-0.3.4.dev34/julearn/model_selection/tests/test_final_model_cv.py

@@ -0,0 +1,53 @@
+"""Provides tests for the final model CV."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+import numpy as np
+from numpy.testing import assert_array_equal
+from sklearn.model_selection import RepeatedStratifiedKFold
+
+from julearn.model_selection.final_model_cv import _JulearnFinalModelCV
+from julearn.utils import _compute_cvmdsum
+
+
+def test_final_model_cv() -> None:
+    """Test the final model CV."""
+    sklearn_cv = RepeatedStratifiedKFold(
+        n_repeats=2, n_splits=5, random_state=42
+    )
+
+    julearn_cv = _JulearnFinalModelCV(sklearn_cv)
+
+    assert julearn_cv.get_n_splits() == 11
+    assert julearn_cv.n_repeats == 2
+
+    n_features = 10
+    n_samples = 123
+    X = np.zeros((n_samples, n_features))
+    y = np.zeros(n_samples)
+
+    all_ju = list(julearn_cv.split(X, y))
+    all_sk = list(sklearn_cv.split(X, y))
+
+    assert len(all_ju) == len(all_sk) + 1
+    for i in range(10):
+        assert_array_equal(all_ju[i][0], all_sk[i][0])
+        assert_array_equal( all_ju[i][1], all_sk[i][1])
+
+    assert all_ju[-1][0].shape[0] == n_samples
+    assert all_ju[-1][1].shape[0] == 2
+    assert_array_equal(all_ju[-1][0], np.arange(n_samples))
+
+
+def test_final_model_cv_mdsum() -> None:
+    """Test the mdsum of the final model CV."""
+    sklearn_cv = RepeatedStratifiedKFold(
+        n_repeats=2, n_splits=5, random_state=42
+    )
+
+    julearn_cv = _JulearnFinalModelCV(sklearn_cv)
+
+    mdsum = _compute_cvmdsum(julearn_cv)
+    mdsum_sk = _compute_cvmdsum(sklearn_cv)
+    assert mdsum == mdsum_sk

julearn-0.3.4.dev34/julearn/model_selection/utils.py

@@ -0,0 +1,55 @@
+"""Utility functions for model selection in julearn."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from typing import TYPE_CHECKING
+
+from sklearn.model_selection import check_cv as sk_check_cv
+
+from .final_model_cv import _JulearnFinalModelCV
+
+
+if TYPE_CHECKING:
+    from ..utils.typing import CVLike
+
+
+def check_cv(
+    cv: "CVLike", classifier: bool = False, include_final_model: bool = False
+) -> "CVLike":
+    """Check the CV instance and return the proper CV for julearn.
+
+    Parameters
+    ----------
+    cv : int, str or cross-validation generator | None
+        Cross-validation splitting strategy to use for model evaluation.
+
+        Options are:
+
+        * None: defaults to 5-fold
+        * int: the number of folds in a `(Stratified)KFold`
+        * CV Splitter (see scikit-learn documentation on CV)
+        * An iterable yielding (train, test) splits as arrays of indices.
+
+    classifier : bool, default=False
+        Whether the task is a classification task, in which case
+        stratified KFold will be used.
+
+    include_final_model : bool, default=False
+        Whether to include the final model in the cross-validation. If true,
+        one more fold will be added to the cross-validation, where the full
+        dataset is used for training and testing
+
+    Returns
+    -------
+    checked_cv : a cross-validator instance.
+        The return value is a cross-validator which generates the train/test
+        splits via the ``split`` method.
+
+    """
+
+    cv = sk_check_cv(cv, classifier=classifier)
+    if include_final_model:
+        cv = _JulearnFinalModelCV(cv)
+
+    return cv

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/pipeline/pipeline_creator.py

@@ -42,6 +42,37 @@ from .target_pipeline import JuTargetPipeline
 from .target_pipeline_creator import TargetPipelineCreator
 
 
+def _should_wrap_this_step(
+    X_types: Dict[str, List[str]],  # noqa: N803
+    apply_to: ColumnTypesLike,
+) -> bool:
+    """Check if we should wrap the step.
+
+    Parameters
+    ----------
+    X_types : Dict[str, List[str]]
+        The types of the columns in the data.
+    apply_to : ColumnTypesLike
+        The types to apply this step to.
+
+    Returns
+    -------
+    bool
+        Whether we should wrap the step.
+
+    """
+
+    # If we have a wildcard, we will not wrap the step
+    if any(x in ["*", ".*"] for x in apply_to):
+        return False
+
+    # If any of the X_types is not in the apply_to, we will wrap the step
+    if any(x not in apply_to for x in X_types.keys()):
+        return True
+
+    return False
+
+
 def _params_to_pipeline(
     param: Any,
     X_types: Dict[str, List],  # noqa: N803
@@ -511,7 +542,9 @@ class PipelineCreator:
             logger.debug(f"\t Params to tune: {step_params_to_tune}")
 
             # Wrap in a JuTransformer if needed
-            if self.wrap and not isinstance(estimator, JuTransformer):
+            if _should_wrap_this_step(
+                X_types, step_dict.apply_to
+            ) and not isinstance(estimator, JuTransformer):
                 estimator = self._wrap_step(
                     name,
                     estimator,
@@ -539,7 +572,9 @@ class PipelineCreator:
             for k, v in model_params.items()
         }
         model_estimator.set_params(**model_params)
-        if self.wrap and not isinstance(model_estimator, JuModelLike):
+        if _should_wrap_this_step(
+            X_types, model_step.apply_to
+        ) and not isinstance(model_estimator, JuModelLike):
             logger.debug(f"Wrapping {model_name}")
             model_estimator = WrapModel(model_estimator, model_step.apply_to)
 
@@ -789,12 +824,11 @@ class PipelineCreator:
                     "this type."
                 )
 
-        self.wrap = needed_types != {"continuous"}
         return X_types
 
     @staticmethod
     def _is_transformer_step(
-        step: Union[str, EstimatorLike, TargetPipelineCreator]
+        step: Union[str, EstimatorLike, TargetPipelineCreator],
     ) -> bool:
         """Check if a step is a transformer."""
         if step in list_transformers():
@@ -805,7 +839,7 @@ class PipelineCreator:
 
     @staticmethod
     def _is_model_step(
-        step: Union[EstimatorLike, str, TargetPipelineCreator]
+        step: Union[EstimatorLike, str, TargetPipelineCreator],
     ) -> bool:
         """Check if a step is a model."""
         if step in list_models():

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/pipeline/tests/test_pipeline_creator.py

@@ -26,10 +26,10 @@ if TYPE_CHECKING:
     from sklearn.pipeline import Pipeline
 
 
-def test_construction_working(
+def test_construction_working_wrapping(
     model: str, preprocess: Union[str, List[str]], problem_type: str
 ) -> None:
-    """Test that the pipeline constructions works as expected.
+    """Test that the pipeline constructions works as expected (wrapping).
 
     Parameters
     ----------
@@ -46,7 +46,7 @@ def test_construction_working(
     for step in preprocess:
         creator.add(step, apply_to="categorical")
     creator.add(model)
-    X_types = {"categorical": ["A"]}
+    X_types = {"categorical": ["A"], "continuous": ["B"]}
     pipeline = creator.to_pipeline(X_types=X_types)
 
     # check preprocessing steps
@@ -72,6 +72,53 @@ def test_construction_working(
     assert len(preprocess) + 2 == len(pipeline.steps)
 
 
+def test_construction_working_nowrapping(
+    model: str, preprocess: Union[str, List[str]], problem_type: str
+) -> None:
+    """Test that the pipeline constructions works as expected (no wrapping).
+
+    Parameters
+    ----------
+    model : str
+        The model to test.
+    preprocess : str or list of str
+        The preprocessing steps to test.
+    problem_type : str
+        The problem type to test.
+
+    """
+    creator = PipelineCreator(problem_type=problem_type)
+    preprocess = preprocess if isinstance(preprocess, list) else [preprocess]
+    for step in preprocess:
+        creator.add(step, apply_to="*")
+    creator.add(model, apply_to=["categorical", "continuous"])
+    X_types = {"categorical": ["A"], "continuous": ["B"]}
+    pipeline = creator.to_pipeline(X_types=X_types)
+
+    # check preprocessing steps
+    # ignoring first step for types and last for model
+    for element in zip(preprocess, pipeline.steps[1:-1]):
+        _preprocess, (name, transformer) = element
+        assert name.startswith(f"{_preprocess}")
+        assert not isinstance(transformer, JuColumnTransformer)
+        assert isinstance(
+            transformer, get_transformer(_preprocess).__class__
+        )
+
+    # check model step
+    model_name, model = pipeline.steps[-1]
+    assert not isinstance(model, WrapModel)
+    assert isinstance(
+        model,
+        get_model(
+            model_name,
+            problem_type=problem_type,
+        ).__class__,
+    )
+    assert len(preprocess) + 2 == len(pipeline.steps)
+
+
+
 def test_fit_and_transform_no_error(
     X_iris: pd.DataFrame,  # noqa: N803
     y_iris: pd.Series,

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/tests/test_api.py

@@ -415,8 +415,8 @@ def test_tune_hyperparam_gridsearch(df_iris: pd.DataFrame) -> None:
     scoring = "accuracy"
 
     np.random.seed(42)
-    cv_outer = RepeatedKFold(n_splits=2, n_repeats=1)
-    cv_inner = RepeatedKFold(n_splits=2, n_repeats=1)
+    cv_outer = RepeatedKFold(n_splits=3, n_repeats=2)
+    cv_inner = RepeatedKFold(n_splits=3, n_repeats=2)
 
     model_params = {"svm__C": [0.01, 0.001]}
     search_params = {"cv": cv_inner}
@@ -434,10 +434,12 @@ def test_tune_hyperparam_gridsearch(df_iris: pd.DataFrame) -> None:
         problem_type="classification",
     )
 
+    assert len(actual["repeat"].unique()) == 2
+
     # Now do the same with scikit-learn
     np.random.seed(42)
-    cv_outer = RepeatedKFold(n_splits=2, n_repeats=1)
-    cv_inner = RepeatedKFold(n_splits=2, n_repeats=1)
+    cv_outer = RepeatedKFold(n_splits=3, n_repeats=2)
+    cv_inner = RepeatedKFold(n_splits=3, n_repeats=2)
 
     clf = make_pipeline(SVC())
     gs = GridSearchCV(
@@ -1225,7 +1227,7 @@ def test_api_stacking_models() -> None:
     # The final model should be a stacking model im which the first estimator
     # is a grid search
     assert isinstance(
-        final.steps[1][1].model.estimators[0][1],  # type: ignore
+        final.steps[1][1].estimators[0][1],  # type: ignore
         GridSearchCV,
     )
 

{julearn-0.3.4.dev19 → julearn-0.3.4.dev34}/julearn/transformers/ju_column_transformer.py

@@ -12,6 +12,7 @@ from sklearn.compose import ColumnTransformer
 from sklearn.utils.validation import check_is_fitted
 
 from ..base import ColumnTypesLike, JuTransformer, ensure_column_types
+from ..config import get_config
 from ..utils.logging import raise_error
 from ..utils.typing import DataLike, EstimatorLike
 
@@ -93,6 +94,9 @@ class JuColumnTransformer(JuTransformer):
             [(self.name, self.transformer, self.apply_to.to_type_selector())],
             verbose_feature_names_out=verbose_feature_names_out,
             remainder="passthrough",
+            n_jobs=None
+            if get_config("enable_parallel_column_transformers")
+            else 1,
         )
         self.column_transformer_.fit(X, y, **fit_params)