autogluon.tabular 1.5.1b20260105__py3-none-any.whl → 1.5.1b20260117__py3-none-any.whl

autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import logging
 import os
-from pathlib import Path
 import time
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
@@ -11,7 +11,7 @@ import pandas as pd
 from autogluon.common.utils.pandas_utils import get_approximate_df_mem_usage
 from autogluon.common.utils.resource_utils import ResourceManager
 from autogluon.common.utils.try_import import try_import_torch
-from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION, QUANTILE
+from autogluon.core.constants import BINARY, MULTICLASS, QUANTILE, REGRESSION
 from autogluon.core.models import AbstractModel
 from autogluon.core.utils import generate_train_test_split
 from autogluon.core.utils.exceptions import TimeLimitExceeded
@@ -39,6 +39,7 @@ class TabPFNMixModel(AbstractModel):
 
     .. versionadded:: 1.2.0
     """
+
     ag_key = "TABPFNMIX"
     ag_name = "TabPFNMix"
     ag_priority = 45
@@ -54,9 +55,10 @@ class TabPFNMixModel(AbstractModel):
     def _get_model_type(self):
         from ._internal.tabpfnmix_classifier import TabPFNMixClassifier
         from ._internal.tabpfnmix_regressor import TabPFNMixRegressor
-        if self.problem_type in ['binary', 'multiclass']:
+
+        if self.problem_type in ["binary", "multiclass"]:
             model_cls = TabPFNMixClassifier
-        elif self.problem_type in ['regression']:
+        elif self.problem_type in ["regression"]:
             model_cls = TabPFNMixRegressor
         else:
             raise AssertionError(f"TabPFN does not support problem_type='{self.problem_type}'")
@@ -74,12 +76,10 @@ class TabPFNMixModel(AbstractModel):
             # weights_path_regressor,  # if specified, overrides weights_path for regression problems
             "n_ensembles": 1,  # FIXME: RENAME: n_estimators
             "max_epochs": 0,  # fine-tuning epochs. Will do pure in-context learning if 0.
-
             # next most important hyperparameters
             "lr": 1.0e-05,
             "max_samples_query": 1024,  # larger = slower but better quality on datasets with at least this many validation samples
             "max_samples_support": 8196,  # larger = slower but better quality on datasets with at least this many training samples
-
             # other hyperparameters
             "early_stopping_patience": 40,  # TODO: Figure out optimal value
             "linear_attention": True,
@@ -89,7 +89,6 @@ class TabPFNMixModel(AbstractModel):
             "use_feature_count_scaling": True,
             "use_quantile_transformer": True,
             "weight_decay": 0,
-
             # architecture hyperparameters, recommended to keep as default unless using a custom pre-trained backbone
             "n_classes": 10,
             "n_features": 100,
@@ -98,7 +97,6 @@ class TabPFNMixModel(AbstractModel):
             "attn_dropout": 0.0,
             "dim": 512,
             "y_as_float_embedding": True,
-
             # utility parameters, recommended to keep as default
             "split_val": False,
             "use_best_epoch": True,
@@ -111,17 +109,30 @@ class TabPFNMixModel(AbstractModel):
     # FIXME: Handle model weights download
     # FIXME: GPU support?
     # FIXME: Save model weights to file instead of pickling?
-    def _fit(self, X: pd.DataFrame, y: pd.Series, X_val: pd.DataFrame = None, y_val: pd.Series = None, time_limit: float = None, num_cpus: int = 1, num_gpus: float = 0, **kwargs):
+    def _fit(
+        self,
+        X: pd.DataFrame,
+        y: pd.Series,
+        X_val: pd.DataFrame = None,
+        y_val: pd.Series = None,
+        time_limit: float = None,
+        num_cpus: int = 1,
+        num_gpus: float = 0,
+        **kwargs,
+    ):
         time_start = time.time()
         try_import_torch()
         import torch
+
         from ._internal.config.config_run import ConfigRun
 
         ag_params = self._get_ag_params()
         max_classes = ag_params.get("max_classes")
         if max_classes is not None and self.num_classes is not None and self.num_classes > max_classes:
             # TODO: Move to earlier stage when problem_type is checked
-            raise AssertionError(f"Max allowed classes for the model is {max_classes}, " f"but found {self.num_classes} classes.")
+            raise AssertionError(
+                f"Max allowed classes for the model is {max_classes}, but found {self.num_classes} classes."
+            )
 
         params = self._get_model_params()
         random_state = params.pop(self.seed_name, self.default_random_seed)
@@ -131,17 +142,26 @@ class TabPFNMixModel(AbstractModel):
 
         # TODO: Make max_rows generic
         if max_rows is not None and isinstance(max_rows, (int, float)) and len(X) > max_rows:
-            raise AssertionError(f"Skipping model due to X having more rows than `ag.max_rows={max_rows}` (len(X)={len(X)})")
+            raise AssertionError(
+                f"Skipping model due to X having more rows than `ag.max_rows={max_rows}` (len(X)={len(X)})"
+            )
 
         # TODO: Make sample_rows generic
         if sample_rows is not None and isinstance(sample_rows, int) and len(X) > sample_rows:
             X, y = self._subsample_data(X=X, y=y, num_rows=sample_rows, random_state=random_state)
 
         # TODO: Make sample_rows generic
-        if X_val is not None and y_val is not None and sample_rows_val is not None and isinstance(sample_rows_val, int) and len(X_val) > sample_rows_val:
+        if (
+            X_val is not None
+            and y_val is not None
+            and sample_rows_val is not None
+            and isinstance(sample_rows_val, int)
+            and len(X_val) > sample_rows_val
+        ):
             X_val, y_val = self._subsample_data(X=X_val, y=y_val, num_rows=sample_rows_val, random_state=random_state)
 
         from ._internal.core.enums import Task
+
         if self.problem_type in [REGRESSION, QUANTILE]:
             task = Task.REGRESSION
             n_classes = 0
@@ -186,7 +206,7 @@ class TabPFNMixModel(AbstractModel):
             logger.log(
                 30,
                 f"WARNING: max_epochs should be > 0 if n_ensembles > 1, otherwise there will be zero quality benefit with slower inference. "
-                f"(max_epochs={cfg.hyperparams['max_epochs']}, n_ensembles={cfg.hyperparams['n_ensembles']})"
+                f"(max_epochs={cfg.hyperparams['max_epochs']}, n_ensembles={cfg.hyperparams['n_ensembles']})",
             )
 
         X = self.preprocess(X)
@@ -211,7 +231,9 @@ class TabPFNMixModel(AbstractModel):
             time_cur = time.time()
             time_left = time_limit - (time_cur - time_start)
             if time_left <= 0:
-                raise TimeLimitExceeded(f"No time remaining to fit model (time_limit={time_limit:.2f}s, time_left={time_left:.2f}s)")
+                raise TimeLimitExceeded(
+                    f"No time remaining to fit model (time_limit={time_limit:.2f}s, time_left={time_left:.2f}s)"
+                )
             time_limit = time_left
 
         self.model = model_cls(
@@ -244,7 +266,9 @@ class TabPFNMixModel(AbstractModel):
         return self
 
     # TODO: Make this generic by creating a generic `preprocess_train` and putting this logic prior to `_preprocess`.
-    def _subsample_data(self, X: pd.DataFrame, y: pd.Series, num_rows: int, random_state: int | None = 0) -> (pd.DataFrame, pd.Series):
+    def _subsample_data(
+        self, X: pd.DataFrame, y: pd.Series, num_rows: int, random_state: int | None = 0
+    ) -> (pd.DataFrame, pd.Series):
         num_rows_to_drop = len(X) - num_rows
         X, _, y, _ = generate_train_test_split(
             X=X,
@@ -282,6 +306,7 @@ class TabPFNMixModel(AbstractModel):
         path = super().save(path=path, verbose=verbose)
         if _model_weights is not None:
             import torch
+
             os.makedirs(self.path, exist_ok=True)
             torch.save(_model_weights, self.weights_path)
             self.model.trainer.model = _model_weights
@@ -294,6 +319,7 @@ class TabPFNMixModel(AbstractModel):
 
         if model._weights_saved:
             import torch
+
             model.model.trainer.model = torch.load(model.weights_path, weights_only=False)  # nosec B614
             model._weights_saved = False
         return model
@@ -327,7 +353,13 @@ class TabPFNMixModel(AbstractModel):
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
         hyperparameters = self._get_model_params()
-        return self.estimate_memory_usage_static(X=X, problem_type=self.problem_type, num_classes=self.num_classes, hyperparameters=hyperparameters, **kwargs)
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
 
     def get_minimum_ideal_resources(self) -> dict[str, int | float]:
         return {"num_cpus": 4}
@@ -344,8 +376,12 @@ class TabPFNMixModel(AbstractModel):
         # TODO: Fitting 4 in parallel still causes many OOM errors with 32 GB of memory on relatively small datasets, so each model is using over 8 GB of memory
         #  The below logic returns a minimum of 8.8 GB, to avoid OOM errors
         data_mem_usage = 5 * get_approximate_df_mem_usage(X).sum()  # rough estimate
-        model_size = 160*1e6  # model weights are ~160 MB  # TODO: Avoid hardcoding, we can derive from the model itself?
-        model_mem_usage = model_size * 5  # Account for 1x copy being fit, 1x copy checkpointed, 2x for optimizer, and 1x for overhead
+        model_size = (
+            160 * 1e6
+        )  # model weights are ~160 MB  # TODO: Avoid hardcoding, we can derive from the model itself?
+        model_mem_usage = (
+            model_size * 5
+        )  # Account for 1x copy being fit, 1x copy checkpointed, 2x for optimizer, and 1x for overhead
         model_fit_usage = model_size * 50  # TODO: This is a placeholder large value to try to avoid OOM errors
         mem_usage_estimate = data_mem_usage + model_mem_usage + model_fit_usage
         return mem_usage_estimate
@@ -361,4 +397,4 @@ class TabPFNMixModel(AbstractModel):
 
     def _more_tags(self) -> dict:
         tags = {"can_refit_full": True}
-        return tags
+        return tags

autogluon/tabular/models/tabpfnv2/tabpfnv2_5_model.py

@@ -61,17 +61,13 @@ class TabPFNModel(AbstractTorchModel):
         # This converts categorical features to numeric via stateful label encoding.
         if self._feature_generator.features_in:
             X = X.copy()
-            X[self._feature_generator.features_in] = self._feature_generator.transform(
-                X=X
-            )
+            X[self._feature_generator.features_in] = self._feature_generator.transform(X=X)
 
             if is_train:
                 # Detect/set cat features and indices
                 if self._cat_features is None:
                     self._cat_features = self._feature_generator.features_in[:]
-                self._cat_indices = [
-                    X.columns.get_loc(col) for col in self._cat_features
-                ]
+                self._cat_indices = [X.columns.get_loc(col) for col in self._cat_features]
 
         return X
 
@@ -121,9 +117,7 @@ class TabPFNModel(AbstractTorchModel):
                 {
                     "name": scaler,
                     "global_transformer_name": hps.pop("preprocessing/global", None),
-                    "categorical_name": hps.pop(
-                        "preprocessing/categoricals", "numeric"
-                    ),
+                    "categorical_name": hps.pop("preprocessing/categoricals", "numeric"),
                     "append_original": hps.pop("preprocessing/append_original", True),
                 }
                 for scaler in hps["preprocessing/scaling"]
@@ -161,9 +155,7 @@ class TabPFNModel(AbstractTorchModel):
 
         # Resolve inference_config
         inference_config = {
-            _k: v
-            for k, v in hps.items()
-            if k.startswith("inference_config/") and (_k := k.split("/")[-1])
+            _k: v for k, v in hps.items() if k.startswith("inference_config/") and (_k := k.split("/")[-1])
         }
         if inference_config:
             hps["inference_config"] = inference_config
@@ -191,9 +183,7 @@ class TabPFNModel(AbstractTorchModel):
 
         return num_cpus, num_gpus
 
-    def get_minimum_resources(
-        self, is_gpu_available: bool = False
-    ) -> dict[str, int | float]:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, int | float]:
         return {
             "num_cpus": 1,
             "num_gpus": 1 if is_gpu_available else 0,
@@ -278,21 +268,15 @@ class TabPFNModel(AbstractTorchModel):
         model_mem = 14489108  # Based on TabPFNv2 default
 
         n_samples, n_features = X.shape[0], min(X.shape[1], 2000)
-        n_feature_groups = (
-            n_features
-        ) / features_per_group + 1  # TODO: Unsure how to calculate this
+        n_feature_groups = (n_features) / features_per_group + 1  # TODO: Unsure how to calculate this
 
         X_mem = n_samples * n_feature_groups * dtype_byte_size
-        activation_mem = (
-            n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
-        )
+        activation_mem = n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
 
         baseline_overhead_mem_est = 1e9  # 1 GB generic overhead
 
         # Add some buffer to each term + 1 GB overhead to be safe
-        return int(
-            model_mem + 4 * X_mem + 2 * activation_mem + baseline_overhead_mem_est
-        )
+        return int(model_mem + 4 * X_mem + 2 * activation_mem + baseline_overhead_mem_est)
 
     @classmethod
     def _class_tags(cls):
@@ -313,12 +297,11 @@ class TabPFNModel(AbstractTorchModel):
         if not _HAS_LOGGED_TABPFN_CPU_WARNING:
             if device == "cpu":
                 logger.log(
-                    20,
-                    "\tRunning TabPFN on CPU. This can be very slow. "
-                    "It is recommended to run TabPFN on a GPU."
+                    20, "\tRunning TabPFN on CPU. This can be very slow. It is recommended to run TabPFN on a GPU."
                 )
                 _HAS_LOGGED_TABPFN_CPU_WARNING = True
 
+
 class RealTabPFNv25Model(TabPFNModel):
     """RealTabPFN-v2.5 version: https://priorlabs.ai/technical-reports/tabpfn-2-5-model-report.
 
@@ -332,9 +315,7 @@ class RealTabPFNv25Model(TabPFNModel):
     ag_key = "REALTABPFN-V2.5"
     ag_name = "RealTabPFN-v2.5"
 
-    default_classification_model: str | None = (
-        "tabpfn-v2.5-classifier-v2.5_default.ckpt"
-    )
+    default_classification_model: str | None = "tabpfn-v2.5-classifier-v2.5_default.ckpt"
     default_regression_model: str | None = "tabpfn-v2.5-regressor-v2.5_default.ckpt"
 
     @staticmethod
@@ -369,7 +350,7 @@ class RealTabPFNv25Model(TabPFNModel):
                 "\tWarning: TabPFN-2.5 is a NONCOMMERCIAL model. "
                 "Usage of this artifact (including through AutoGluon) is not permitted "
                 "for commercial tasks unless granted explicit permission "
-                "by the model authors (PriorLabs)."
+                "by the model authors (PriorLabs).",
             )  # Aligning with TabPFNv25 license
             _HAS_LOGGED_TABPFN_NONCOMMERICAL = True  # Avoid repeated logging
 
@@ -388,9 +369,7 @@ class RealTabPFNv2Model(TabPFNModel):
     ag_name = "RealTabPFN-v2"
 
     # TODO: Verify if this is the same as the "default" ckpt
-    default_classification_model: str | None = (
-        "tabpfn-v2-classifier-finetuned-zk73skhh.ckpt"
-    )
+    default_classification_model: str | None = "tabpfn-v2-classifier-finetuned-zk73skhh.ckpt"
     default_regression_model: str | None = "tabpfn-v2-regressor-v2_default.ckpt"
 
     def _get_default_auxiliary_params(self) -> dict:
@@ -414,11 +393,11 @@ class RealTabPFNv2Model(TabPFNModel):
     # FIXME: Avoid code dupe. This one has 500 features max, 2.5 has 2000.
     @classmethod
     def _estimate_memory_usage_static(
-            cls,
-            *,
-            X: pd.DataFrame,
-            hyperparameters: dict | None = None,
-            **kwargs,
+        cls,
+        *,
+        X: pd.DataFrame,
+        hyperparameters: dict | None = None,
+        **kwargs,
     ) -> int:
         """Heuristic memory estimate based on TabPFN's memory estimate logic in:
         https://github.com/PriorLabs/TabPFN/blob/57a2efd3ebdb3886245e4d097cefa73a5261a969/src/tabpfn/model/memory.py#L147.
@@ -434,18 +413,12 @@ class RealTabPFNv2Model(TabPFNModel):
         model_mem = 14489108  # Based on TabPFNv2 default
 
         n_samples, n_features = X.shape[0], min(X.shape[1], 500)
-        n_feature_groups = (
-                               n_features
-                           ) / features_per_group + 1  # TODO: Unsure how to calculate this
+        n_feature_groups = (n_features) / features_per_group + 1  # TODO: Unsure how to calculate this
 
         X_mem = n_samples * n_feature_groups * dtype_byte_size
-        activation_mem = (
-                n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
-        )
+        activation_mem = n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
 
         baseline_overhead_mem_est = 1e9  # 1 GB generic overhead
 
         # Add some buffer to each term + 1 GB overhead to be safe
-        return int(
-            model_mem + 4 * X_mem + 2 * activation_mem + baseline_overhead_mem_est
-        )
+        return int(model_mem + 4 * X_mem + 2 * activation_mem + baseline_overhead_mem_est)

autogluon/tabular/models/tabprep/prep_mixin.py

@@ -6,10 +6,12 @@ from typing import Type
 import numpy as np
 import pandas as pd
 
-from autogluon.features import ArithmeticFeatureGenerator
-from autogluon.features import CategoricalInteractionFeatureGenerator
-from autogluon.features import OOFTargetEncodingFeatureGenerator
-from autogluon.features import BulkFeatureGenerator
+from autogluon.features import (
+    ArithmeticFeatureGenerator,
+    BulkFeatureGenerator,
+    CategoricalInteractionFeatureGenerator,
+    OOFTargetEncodingFeatureGenerator,
+)
 from autogluon.features.generators.abstract import AbstractFeatureGenerator
 
 logger = logging.getLogger(__name__)
@@ -66,21 +68,23 @@ class ModelAgnosticPrepMixin:
         X_nunique = X.nunique().values
         n_categorical = X.select_dtypes(exclude=[np.number]).shape[1]
         n_numeric = X.loc[:, X_nunique > 2].select_dtypes(include=[np.number]).shape[1]
-        n_binary = X.loc[:, X_nunique <= 2].select_dtypes(include=[np.number]).shape[
-            1]  # NOTE: It can happen that features have less than two unique values if cleaning is applied before the bagging, i.e. Bioresponse
+        n_binary = (
+            X.loc[:, X_nunique <= 2].select_dtypes(include=[np.number]).shape[1]
+        )  # NOTE: It can happen that features have less than two unique values if cleaning is applied before the bagging, i.e. Bioresponse
 
         assert n_numeric + n_categorical + n_binary == X.shape[1]  # NOTE: FOr debugging, to be removed later
         for preprocessor_cls_name, init_params in prep_params:
-            if preprocessor_cls_name == 'ArithmeticFeatureGenerator':
+            if preprocessor_cls_name == "ArithmeticFeatureGenerator":
                 prep_cls = ArithmeticFeatureGenerator(target_type=self.problem_type, **init_params)
-            elif preprocessor_cls_name == 'CategoricalInteractionFeatureGenerator':
+            elif preprocessor_cls_name == "CategoricalInteractionFeatureGenerator":
                 prep_cls = CategoricalInteractionFeatureGenerator(target_type=self.problem_type, **init_params)
-            elif preprocessor_cls_name == 'OOFTargetEncodingFeatureGenerator':
+            elif preprocessor_cls_name == "OOFTargetEncodingFeatureGenerator":
                 prep_cls = OOFTargetEncodingFeatureGenerator(target_type=self.problem_type, **init_params)
             else:
                 raise ValueError(f"Unknown preprocessor class name: {preprocessor_cls_name}")
-            n_numeric, n_categorical, n_binary = prep_cls.estimate_new_dtypes(n_numeric, n_categorical, n_binary,
-                                                                              num_classes=self.num_classes)
+            n_numeric, n_categorical, n_binary = prep_cls.estimate_new_dtypes(
+                n_numeric, n_categorical, n_binary, num_classes=self.num_classes
+            )
 
         return n_numeric, n_categorical, n_binary
 
@@ -108,7 +112,7 @@ class ModelAgnosticPrepMixin:
             df_lst.append(X_estimate_numeric)
         if n_categorical > 0:
             cardinality = int(X.select_dtypes(exclude=[np.number]).nunique().mean())
-            X_estimate = np.random.randint(0, cardinality, [shape, n_categorical]).astype('str')
+            X_estimate = np.random.randint(0, cardinality, [shape, n_categorical]).astype("str")
             X_estimate_cat = pd.DataFrame(X_estimate)
             df_lst.append(X_estimate_cat)
         if n_binary > 0:
@@ -126,9 +130,9 @@ class ModelAgnosticPrepMixin:
         )
 
     def _init_preprocessor(
-            self,
-            preprocessor_cls: Type[AbstractFeatureGenerator] | str,
-            init_params: dict | None,
+        self,
+        preprocessor_cls: Type[AbstractFeatureGenerator] | str,
+        init_params: dict | None,
     ) -> AbstractFeatureGenerator:
         if isinstance(preprocessor_cls, str):
             preprocessor_cls = _feature_generator_class_map[preprocessor_cls]
@@ -188,23 +192,27 @@ class ModelAgnosticPrepMixin:
         if len(preprocessors) == 1 and isinstance(preprocessors[0], AbstractFeatureGenerator):
             return preprocessors
         else:
-            preprocessors = [BulkFeatureGenerator(
-                generators=preprocessors,
-                # TODO: "false_recursive" technically can slow down inference, but need to optimize `True` first
-                #  Refer to `Bioresponse` dataset where setting to `True` -> 200s fit time vs `false_recursive` -> 1s fit time
-                remove_unused_features="false_recursive",
-                post_drop_duplicates=True,
-                passthrough=True,
-                passthrough_types=passthrough_types,
-                verbosity=0,
-            )]
+            preprocessors = [
+                BulkFeatureGenerator(
+                    generators=preprocessors,
+                    # TODO: "false_recursive" technically can slow down inference, but need to optimize `True` first
+                    #  Refer to `Bioresponse` dataset where setting to `True` -> 200s fit time vs `false_recursive` -> 1s fit time
+                    remove_unused_features="false_recursive",
+                    post_drop_duplicates=True,
+                    passthrough=True,
+                    passthrough_types=passthrough_types,
+                    verbosity=0,
+                )
+            ]
             return preprocessors
 
     def _preprocess(self, X: pd.DataFrame, y=None, is_train: bool = False, **kwargs):
         if is_train:
             self.preprocessors = self.get_preprocessors()
             if self.preprocessors:
-                assert y is not None, f"y must be specified to fit preprocessors... Likely the inheriting class isn't passing `y` in its `preprocess` call."
+                assert y is not None, (
+                    f"y must be specified to fit preprocessors... Likely the inheriting class isn't passing `y` in its `preprocess` call."
+                )
                 # FIXME: add `post_drop_useless`, example: anneal has many useless features
                 feature_metadata_in = self._feature_metadata
                 for prep in self.preprocessors:

autogluon/tabular/models/tabular_nn/compilers/onnx.py

@@ -47,12 +47,24 @@ def quantile_transformer_converter(scope, operator, container):
     if opv < 18:
         C_col = OnnxSplit(C, axis=1, output_names=[f"C_col{x}" for x in range(op.n_features_in_)], op_version=opv)
     else:
-        C_col = OnnxSplit(C, axis=1, num_outputs=C.shape[1], output_names=[f"C_col{x}" for x in range(op.n_features_in_)], op_version=opv)
+        C_col = OnnxSplit(
+            C,
+            axis=1,
+            num_outputs=C.shape[1],
+            output_names=[f"C_col{x}" for x in range(op.n_features_in_)],
+            op_version=opv,
+        )
     C_col.add_to(scope, container)
     if opv < 18:
         X_col = OnnxSplit(X, axis=1, output_names=[f"X_col{x}" for x in range(op.n_features_in_)], op_version=opv)
     else:
-        X_col = OnnxSplit(X, axis=1, num_outputs=X.type.shape[1], output_names=[f"X_col{x}" for x in range(op.n_features_in_)], op_version=opv)
+        X_col = OnnxSplit(
+            X,
+            axis=1,
+            num_outputs=X.type.shape[1],
+            output_names=[f"X_col{x}" for x in range(op.n_features_in_)],
+            op_version=opv,
+        )
     X_col.add_to(scope, container)
     Y_col = []
     for feature_idx in range(op.n_features_in_):
@@ -83,8 +95,12 @@ def quantile_transformer_converter(scope, operator, container):
         )
         references = np.clip(norm.ppf(op.references_), -5.2, 5.2).astype(dtype)
         cst = np.broadcast_to(references, (batch_size, n_quantiles))
-        argmin_reshaped = OnnxReshape(argmin, np.array([batch_size, 1], dtype=np.int64), output_names=[f"reshape_col{feature_idx}"])
-        ref = OnnxGatherElements(cst, argmin_reshaped, axis=1, op_version=opv, output_names=[f"gathernd_col{feature_idx}"])
+        argmin_reshaped = OnnxReshape(
+            argmin, np.array([batch_size, 1], dtype=np.int64), output_names=[f"reshape_col{feature_idx}"]
+        )
+        ref = OnnxGatherElements(
+            cst, argmin_reshaped, axis=1, op_version=opv, output_names=[f"gathernd_col{feature_idx}"]
+        )
         ref_reshape = OnnxReshape(ref, np.array([batch_size, 1], dtype=np.int64), output_names=[f"Y_col{feature_idx}"])
         ref_cast = OnnxCast(ref_reshape, to=1, op_version=opv, output_names=[f"ref_cast{feature_idx}"])
         Y_col.append(ref_cast)
@@ -147,9 +163,17 @@ def _encoder_handle_unknown_transformer_converter(scope, operator, container, na
 
     C_col = op.categories_
     if opv < 18:
-        X_col = OnnxSplit(X, axis=1, output_names=[f"{name_prefix}X_col{x}" for x in range(num_categories)], op_version=opv)
+        X_col = OnnxSplit(
+            X, axis=1, output_names=[f"{name_prefix}X_col{x}" for x in range(num_categories)], op_version=opv
+        )
     else:
-        X_col = OnnxSplit(X, axis=1, num_outputs=X.type.shape[1], output_names=[f"{name_prefix}X_col{x}" for x in range(num_categories)], op_version=opv)
+        X_col = OnnxSplit(
+            X,
+            axis=1,
+            num_outputs=X.type.shape[1],
+            output_names=[f"{name_prefix}X_col{x}" for x in range(num_categories)],
+            op_version=opv,
+        )
     X_col.add_to(scope, container)
     Y_col = []
     for feature_idx in range(num_categories):
@@ -194,7 +218,9 @@ def _encoder_handle_unknown_transformer_converter(scope, operator, container, na
                 output_names=[f"{name_prefix}Y_col{feature_idx}"],
                 op_version=opv,
             )
-            onehot_cast = OnnxCast(onehot_reshaped, to=1, op_version=opv, output_names=[f"{name_prefix}onehot_cast{feature_idx}"])
+            onehot_cast = OnnxCast(
+                onehot_reshaped, to=1, op_version=opv, output_names=[f"{name_prefix}onehot_cast{feature_idx}"]
+            )
             Y_col.append(onehot_cast)
         else:
             argmin_reshaped = OnnxReshape(
@@ -203,7 +229,9 @@ def _encoder_handle_unknown_transformer_converter(scope, operator, container, na
                 output_names=[f"{name_prefix}Y_col{feature_idx}"],
                 op_version=opv,
             )
-            argmin_cast = OnnxCast(argmin_reshaped, to=1, op_version=opv, output_names=[f"{name_prefix}argmin_cast{feature_idx}"])
+            argmin_cast = OnnxCast(
+                argmin_reshaped, to=1, op_version=opv, output_names=[f"{name_prefix}argmin_cast{feature_idx}"]
+            )
             Y_col.append(argmin_cast)
     Y = OnnxConcat(*Y_col, axis=1, op_version=opv, output_names=out[:1])
     Y.add_to(scope, container)