AutoTabPFNRegressor: ValueError: Buffer dtype mismatch, expected 'const float32_t' but got 'double'

[Mccti078]

Describe the bug

Hi Tabpfn,

I'm trying to use AutoTabPFNRegressor to train a tabular model. I keep getting the below error. I can't seem to fix it. For context, I have no problem using TabPFNRegressor for the same dataset.

My apologies if this is user error, but I am at a bit of a dead end.

Thank you

2025-02-05 20:44:50 INFO Using default preset for Post Hoc Ensemble.
2025-02-05 20:44:50 INFO Using categorical_feature_indices: [2]
2025-02-05 20:44:50 INFO Using task type: regression
2025-02-05 20:44:50 INFO Obtaining TabPFN models from a random portfolio.
2025-02-05 20:44:52 INFO Using 100 base models: ['default_tabpfn_model_0', 'random_tabpfn_model_1', 'random_rf_pfn_model_2', 'random_tabpfn_model_3', 'random_rf_pfn_model_4', 'random_rf_pfn_model_5', 'random_rf_pfn_model_6', 'random_rf_pfn_model_7', 'random_tabpfn_model_8', 'random_tabpfn_model_9', 'random_rf_pfn_model_10', 'random_rf_pfn_model_11', 'random_tabpfn_model_12', 'random_rf_pfn_model_13', 'random_tabpfn_model_14', 'random_tabpfn_model_15', 'random_rf_pfn_model_16', 'random_tabpfn_model_17', 'random_tabpfn_model_18', 'random_rf_pfn_model_19', 'random_rf_pfn_model_20', 'random_rf_pfn_model_21', 'random_tabpfn_model_22', 'random_rf_pfn_model_23', 'random_tabpfn_model_24', 'random_tabpfn_model_25', 'random_rf_pfn_model_26', 'random_tabpfn_model_27', 'random_tabpfn_model_28', 'random_rf_pfn_model_29', 'random_tabpfn_model_30', 'random_rf_pfn_model_31', 'random_tabpfn_model_32', 'random_tabpfn_model_33', 'random_rf_pfn_model_34', 'random_tabpfn_model_35', 'random_rf_pfn_model_36', 'random_rf_pfn_model_37', 'random_tabpfn_model_38', 'random_rf_pfn_model_39', 'random_tabpfn_model_40', 'random_tabpfn_model_41', 'random_tabpfn_model_42', 'random_rf_pfn_model_43', 'random_tabpfn_model_44', 'random_tabpfn_model_45', 'random_rf_pfn_model_46', 'random_tabpfn_model_47', 'random_rf_pfn_model_48', 'random_tabpfn_model_49', 'random_tabpfn_model_50', 'random_tabpfn_model_51', 'random_tabpfn_model_52', 'random_rf_pfn_model_53', 'random_tabpfn_model_54', 'random_tabpfn_model_55', 'random_rf_pfn_model_56', 'random_rf_pfn_model_57', 'random_rf_pfn_model_58', 'random_tabpfn_model_59', 'random_rf_pfn_model_60', 'random_tabpfn_model_61', 'random_rf_pfn_model_62', 'random_rf_pfn_model_63', 'random_tabpfn_model_64', 'random_rf_pfn_model_65', 'random_rf_pfn_model_66', 'random_rf_pfn_model_67', 'random_tabpfn_model_68', 'random_tabpfn_model_69', 'random_tabpfn_model_70', 'random_rf_pfn_model_71', 'random_tabpfn_model_72', 'random_rf_pfn_model_73', 'random_rf_pfn_model_74', 'random_rf_pfn_model_75', 'random_rf_pfn_model_76', 'random_rf_pfn_model_77', 'random_rf_pfn_model_78', 'random_tabpfn_model_79', 'random_rf_pfn_model_80', 'random_tabpfn_model_81', 'random_tabpfn_model_82', 'random_tabpfn_model_83', 'random_tabpfn_model_84', 'random_tabpfn_model_85', 'random_tabpfn_model_86', 'random_rf_pfn_model_87', 'random_rf_pfn_model_88', 'random_tabpfn_model_89', 'random_tabpfn_model_90', 'random_rf_pfn_model_91', 'random_rf_pfn_model_92', 'random_rf_pfn_model_93', 'random_tabpfn_model_94', 'random_tabpfn_model_95', 'random_tabpfn_model_96', 'random_tabpfn_model_97', 'random_rf_pfn_model_98', 'random_rf_pfn_model_99']
2025-02-05 20:44:52 INFO Starting 80-repeated holdout validation with holdout_frac=0.33.
2025-02-05 20:44:52 INFO Set time limit to 2500 seconds. We will early stop validation if needed.
2025-02-05 20:44:52 INFO Yield data for model default_tabpfn_model_0 and split 0 (repeat=1).
2025-02-05 20:45:43 INFO Yield data for model random_tabpfn_model_1 and split 0 (repeat=1).
2025-02-05 20:46:00 INFO Yield data for model random_rf_pfn_model_2 and split 0 (repeat=1).
2025-02-05 20:46:00 INFO Using default preset for Post Hoc Ensemble.
2025-02-05 20:46:00 INFO Using categorical_feature_indices: [2]
2025-02-05 20:46:00 INFO Using task type: regression
2025-02-05 20:46:00 INFO Obtaining TabPFN models from a random portfolio.

An error occurred: Buffer dtype mismatch, expected 'const float32_t' but got 'double'

Full traceback:
Traceback (most recent call last):
File "C:\Users\User\AppData\Local\Temp\ipykernel_6384\507384520.py", line 75, in run_tabpfn_tuned
model.fit(X_train_np, y_train_np)
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\sklearn_interface.py", line 222, in fit
self.predictor_.fit(
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\pfn_phe.py", line 333, in fit
self._ens_model.fit(X, y)
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\greedy_weighted_ensemble.py", line 234, in fit
weights = self.get_weights(X, y)
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\greedy_weighted_ensemble.py", line 173, in get_weights
oof_proba = self.get_oof_per_estimator(X, y)
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\abstract_validation_utils.py", line 372, in get_oof_per_estimator
self._fill_predictions_in_place(
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\abstract_validation_utils.py", line 127, in _fill_predictions_in_place
base_model.fit(fold_X_train, fold_y_train)
File "C:\Users\User\tabpfn-extensions\src\tabpfn_extensions\rf_pfn\SklearnBasedRandomForestTabPFN.py", line 98, in fit
super().fit(X, y)
File "C:\Users\User\anaconda3\envs\ml_testing\lib\site-packages\sklearn\base.py", line 1351, in wrapper
return fit_method(estimator, *args, **kwargs)
File "C:\Users\User\anaconda3\envs\ml_testing\lib\site-packages\sklearn\ensemble_forest.py", line 377, in fit
estimator._compute_missing_values_in_feature_mask(
File "C:\Users\User\anaconda3\envs\ml_testing\lib\site-packages\sklearn\tree_classes.py", line 228, in _compute_missing_values_in_feature_mask
missing_values_in_feature_mask = _any_isnan_axis0(X)
File "sklearn\tree\_utils.pyx", line 450, in sklearn.tree._utils._any_isnan_axis0
ValueError: Buffer dtype mismatch, expected 'const float32_t' but got 'double'

Steps/Code to Reproduce

No response

Expected Results

No response

Actual Results

No response

Versions

[LeoGrin]

Hi @Mccti078 !
Thanks for the report :) Would you be able to share a minimal reproducible example?

[Mccti078]

Hello @LeoGrin yes absolutely. I have a jupyter notebook and a dataset I can share with you. Perhaps I could email it to you?

[LeoGrin]

Hey @Mccti078, thanks a lot! This should actually be fixed by PriorLabs/tabpfn-extensions#23, could you upgrade your tabpfn-extension package and try again?

[noahho]

Please reopen if not fixed! :-)

[Mccti078]

Hello, sorry for the late reply! thanks very much for responding. The original issue does now seem to be fixed. However, I now seem to be getting another error. I'm sorry if it is user error but I have also tried unsuccessfully to fix it. ---------------------------------------------------------------------------
BracketError Traceback (most recent call last)
Cell In[13], line 2
1 # Example usage
----> 2 model, predictions = run_tabpfn_tuned(
3 df=df_test,
4 y_col='tev_to_revenue',
5 cat_cols=['ff_code'],
6 test_size=0.2,
7 max_time=2500
8 )

Cell In[9], line 62, in run_tabpfn_tuned(df, y_col, cat_cols, test_size, max_time, random_state)
59 model = AutoTabPFNRegressor(max_time=max_time, categorical_feature_indices=categorical_feature_indices)
61 # Train and predict
---> 62 model.fit(X_train_np, y_train_np)
63 preds = model.predict(X_test_np)
65 return model, preds

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\sklearn_interface.py:222, in AutoTabPFNRegressor.fit(self, X, y, categorical_feature_indices)
208 np.random.seed(rnd.randint(0, MAX_INT)) # noqa: NPY002
210 self.predictor_ = AutoPostHocEnsemblePredictor(
211 preset=self.preset,
212 task_type=TaskType.REGRESSION,
(...)
219 **self.phe_init_args_,
220 )
--> 222 self.predictor_.fit(
223 X,
224 y,
225 categorical_feature_indices=self.categorical_feature_indices,
226 )
228 # -- Sklearn required values
229 self.n_features_in_ = self.predictor_.n_features_in_

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\pfn_phe.py:333, in AutoPostHocEnsemblePredictor.fit(self, X, y, categorical_feature_indices)
316 self._estimators, model_family_per_estimator = self._collect_base_models(
317 categorical_feature_indices=categorical_feature_indices,
318 )
320 self._ens_model = self._ens_model(
321 estimators=self._estimators,
322 seed=self.ges_random_state,
(...)
330 model_family_per_estimator=model_family_per_estimator,
331 )
--> 333 self._ens_model.fit(X, y)
335 return self

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\greedy_weighted_ensemble.py:234, in GreedyWeightedEnsemble.fit(self, X, y)
233 def fit(self, X, y):
--> 234 weights = self.get_weights(X, y)
236 final_weights = []
237 base_models = []

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\greedy_weighted_ensemble.py:173, in GreedyWeightedEnsemble.get_weights(self, X, y)
172 def get_weights(self, X, y):
--> 173 oof_proba = self.get_oof_per_estimator(X, y)
174 self.model_family_per_estimator = (
175 self.model_family_per_estimator
176 if self.model_family_per_estimator is not None
177 else ["X"] * len(self._estimators)
178 )
179 self._model_family_per_estimator = self.model_family_per_estimator[
180 : len(self._estimators)
181 ]

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\abstract_validation_utils.py:372, in AbstractValidationUtils.get_oof_per_estimator(self, X, y, return_loss_per_estimator, impute_dropped_instances, _extra_processing)
369 to_pass_holdout_index_hits = holdout_index_hits
370 holdout_index_hit_counts = current_repeat
--> 372 self._fill_predictions_in_place(
373 model_i=model_i,
374 base_model=base_model,
375 oof_proba_list=oof_proba_list,
376 X=X,
377 y=y,
378 train_index=train_index,
379 test_index=test_index,
380 loss_per_estimator=loss_per_estimator,
381 holdout_index_hits=to_pass_holdout_index_hits,
382 split_i=split_i,
383 _extra_processing=_extra_processing,
384 )
386 if check_for_repeat_early_stopping: # True after every repeat.
387 ran_repeats = current_repeat

File ~\OneDrive\Python\Project\Scripts\Assignment\tabpfn-extensions\src\tabpfn_extensions\post_hoc_ensembles\abstract_validation_utils.py:127, in AbstractValidationUtils._fill_predictions_in_place(self, model_i, base_model, oof_proba_list, X, y, train_index, test_index, loss_per_estimator, holdout_index_hits, _extra_processing, split_i)
123 fold_y_train, fold_y_test = y[train_index], y[test_index]
124 # base_model = copy.deepcopy(base_model) # FIXME: think about adding this for safety but will likely slow down (due to having to load model again)
125
126 # Default base models case
--> 127 base_model.fit(fold_X_train, fold_y_train)
129 pred = self._predict_oof(base_model, fold_X_test)
131 oof_proba_list[model_i][test_index] += pred

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\regressor.py:504, in TabPFNRegressor.fit(self, X, y)
499 self.renormalized_criterion_ = FullSupportBarDistribution(
500 self.bardist_.borders * self.y_train_std_ + self.y_train_mean_,
501 ).float()
503 # Create the inference engine
--> 504 self.executor_ = create_inference_engine(
505 X_train=X,
506 y_train=y,
507 model=self.model_,
508 ensemble_configs=ensemble_configs,
509 cat_ix=self.inferred_categorical_indices_,
510 fit_mode=self.fit_mode,
511 device_=self.device_,
512 rng=rng,
513 n_jobs=self.n_jobs,
514 byte_size=byte_size,
515 forced_inference_dtype_=self.forced_inference_dtype_,
516 memory_saving_mode=self.memory_saving_mode,
517 use_autocast_=self.use_autocast_,
518 )
520 return self

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\base.py:213, in create_inference_engine(X_train, y_train, model, ensemble_configs, cat_ix, fit_mode, device_, rng, n_jobs, byte_size, forced_inference_dtype_, memory_saving_mode, use_autocast_)
200 engine = InferenceEngineOnDemand.prepare(
201 X_train=X_train,
202 y_train=y_train,
(...)
210 save_peak_mem=memory_saving_mode,
211 )
212 elif fit_mode == "fit_preprocessors":
--> 213 engine = InferenceEngineCachePreprocessing.prepare(
214 X_train=X_train,
215 y_train=y_train,
216 cat_ix=cat_ix,
217 ensemble_configs=ensemble_configs,
218 n_workers=n_jobs,
219 model=model,
220 rng=rng,
221 dtype_byte_size=byte_size,
222 force_inference_dtype=forced_inference_dtype_,
223 save_peak_mem=memory_saving_mode,
224 )
225 elif fit_mode == "fit_with_cache":
226 engine = InferenceEngineCacheKV.prepare(
227 X_train=X_train,
228 y_train=y_train,
(...)
238 autocast=use_autocast_,
239 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\inference.py:269, in InferenceEngineCachePreprocessing.prepare(cls, X_train, y_train, cat_ix, model, ensemble_configs, n_workers, rng, dtype_byte_size, force_inference_dtype, save_peak_mem)
243 """Prepare the inference engine.
244
245 Args:
(...)
258 The prepared inference engine.
259 """
260 itr = fit_preprocessing(
261 configs=ensemble_configs,
262 X_train=X_train,
(...)
267 parallel_mode="block",
268 )
--> 269 configs, preprocessors, X_trains, y_trains, cat_ixs = list(zip(*itr))
270 return InferenceEngineCachePreprocessing(
271 X_trains=X_trains,
272 y_trains=y_trains,
(...)
279 save_peak_mem=save_peak_mem,
280 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\preprocessing.py:664, in fit_preprocessing(configs, X_train, y_train, random_state, cat_ix, n_workers, parallel_mode)
661 worker_func = joblib.delayed(func)
663 seeds = rng.integers(0, np.iinfo(np.int32).max, len(configs))
--> 664 yield from executor( # type: ignore
665 [
666 worker_func(config, X_train, y_train, seed)
667 for config, seed in zip(configs, seeds)
668 ],
669 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\joblib\parallel.py:1918, in Parallel.call(self, iterable)
1916 output = self._get_sequential_output(iterable)
1917 next(output)
-> 1918 return output if self.return_generator else list(output)
1920 # Let's create an ID that uniquely identifies the current call. If the
1921 # call is interrupted early and that the same instance is immediately
1922 # re-used, this id will be used to prevent workers that were
1923 # concurrently finalizing a task from the previous call to run the
1924 # callback.
1925 with self._lock:

File ~\anaconda3\envs\ml_testing\lib\site-packages\joblib\parallel.py:1847, in Parallel._get_sequential_output(self, iterable)
1845 self.n_dispatched_batches += 1
1846 self.n_dispatched_tasks += 1
-> 1847 res = func(*args, **kwargs)
1848 self.n_completed_tasks += 1
1849 self.print_progress()

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\preprocessing.py:571, in fit_preprocessing_one(config, X_train, y_train, random_state, cat_ix)
568 y_train = y_train.copy()
570 preprocessor = config.to_pipeline(random_state=static_seed)
--> 571 res = preprocessor.fit_transform(X_train, cat_ix)
573 # TODO(eddiebergman): Not a fan of this, wish it was more transparent, but we want
574 # to distuinguish what to do with the ys based on the ensemble config type
575 if isinstance(config, RegressorEnsembleConfig):

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\model\preprocessing.py:398, in SequentialFeatureTransformer.fit_transform(self, X, categorical_features)
391 """Fit and transform the data using the fitted pipeline.
392
393 Args:
394 X: 2d array of shape (n_samples, n_features)
395 categorical_features: list of indices of categorical features.
396 """
397 for step in self.steps:
--> 398 X, categorical_features = step.fit_transform(X, categorical_features)
399 assert isinstance(categorical_features, list), (
400 f"The {step=} must return list of categorical features,"
401 f" but {type(step)} returned {categorical_features}"
402 )
404 self.categorical_features_ = categorical_features

File ~\anaconda3\envs\ml_testing\lib\site-packages\tabpfn\model\preprocessing.py:987, in ReshapeFeatureDistributionsStep.fit_transform(self, X, categorical_features)
981 n_samples, n_features = X.shape
982 transformer, cat_ix = self.set_transformer_and_cat_ix(
983 n_samples,
984 n_features,
985 categorical_features,
986 )
--> 987 Xt = transformer.fit_transform(X[:, self.subsampled_features])
988 self.categorical_features_after_transform_ = cat_ix
989 self.transformer_ = transformer

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\utils_set_output.py:273, in _wrap_method_output..wrapped(self, X, *args, **kwargs)
271 @wraps(f)
272 def wrapped(self, X, *args, **kwargs):
--> 273 data_to_wrap = f(self, X, *args, **kwargs)
274 if isinstance(data_to_wrap, tuple):
275 # only wrap the first output for cross decomposition
276 return_tuple = (
277 _wrap_data_with_container(method, data_to_wrap[0], X, self),
278 *data_to_wrap[1:],
279 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\base.py:1351, in _fit_context..decorator..wrapper(estimator, *args, **kwargs)
1344 estimator._validate_params()
1346 with config_context(
1347 skip_parameter_validation=(
1348 prefer_skip_nested_validation or global_skip_validation
1349 )
1350 ):
-> 1351 return fit_method(estimator, *args, **kwargs)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\compose_column_transformer.py:914, in ColumnTransformer.fit_transform(self, X, y, **params)
911 else:
912 routed_params = self._get_empty_routing()
--> 914 result = self._call_func_on_transformers(
915 X,
916 y,
917 _fit_transform_one,
918 column_as_labels=False,
919 routed_params=routed_params,
920 )
922 if not result:
923 self._update_fitted_transformers([])

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\compose_column_transformer.py:823, in ColumnTransformer._call_func_on_transformers(self, X, y, func, column_as_labels, routed_params)
811 extra_args = {}
812 jobs.append(
813 delayed(func)(
814 transformer=clone(trans) if not fitted else trans,
(...)
820 )
821 )
--> 823 return Parallel(n_jobs=self.n_jobs)(jobs)
825 except ValueError as e:
826 if "Expected 2D array, got 1D array instead" in str(e):

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\utils\parallel.py:67, in Parallel.call(self, iterable)
62 config = get_config()
63 iterable_with_config = (
64 (_with_config(delayed_func, config), args, kwargs)
65 for delayed_func, args, kwargs in iterable
66 )
---> 67 return super().call(iterable_with_config)

File ~\anaconda3\envs\ml_testing\lib\site-packages\joblib\parallel.py:1918, in Parallel.call(self, iterable)
1916 output = self._get_sequential_output(iterable)
1917 next(output)
-> 1918 return output if self.return_generator else list(output)
1920 # Let's create an ID that uniquely identifies the current call. If the
1921 # call is interrupted early and that the same instance is immediately
1922 # re-used, this id will be used to prevent workers that were
1923 # concurrently finalizing a task from the previous call to run the
1924 # callback.
1925 with self._lock:

File ~\anaconda3\envs\ml_testing\lib\site-packages\joblib\parallel.py:1847, in Parallel._get_sequential_output(self, iterable)
1845 self.n_dispatched_batches += 1
1846 self.n_dispatched_tasks += 1
-> 1847 res = func(*args, **kwargs)
1848 self.n_completed_tasks += 1
1849 self.print_progress()

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\utils\parallel.py:129, in _FuncWrapper.call(self, *args, **kwargs)
127 config = {}
128 with config_context(**config):
--> 129 return self.function(*args, **kwargs)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\pipeline.py:1303, in _fit_transform_one(transformer, X, y, weight, message_clsname, message, params)
1301 with _print_elapsed_time(message_clsname, message):
1302 if hasattr(transformer, "fit_transform"):
-> 1303 res = transformer.fit_transform(X, y, **params.get("fit_transform", {}))
1304 else:
1305 res = transformer.fit(X, y, **params.get("fit", {})).transform(
1306 X, **params.get("transform", {})
1307 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\base.py:1351, in _fit_context..decorator..wrapper(estimator, *args, **kwargs)
1344 estimator._validate_params()
1346 with config_context(
1347 skip_parameter_validation=(
1348 prefer_skip_nested_validation or global_skip_validation
1349 )
1350 ):
-> 1351 return fit_method(estimator, *args, **kwargs)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\pipeline.py:535, in Pipeline.fit_transform(self, X, y, **params)
492 """Fit the model and transform with the final estimator.
493
494 Fit all the transformers one after the other and sequentially transform
(...)
532 Transformed samples.
533 """
534 routed_params = self._check_method_params(method="fit_transform", props=params)
--> 535 Xt = self._fit(X, y, routed_params)
537 last_step = self._final_estimator
538 with _print_elapsed_time("Pipeline", self._log_message(len(self.steps) - 1)):

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\pipeline.py:408, in Pipeline._fit(self, X, y, routed_params)
406 cloned_transformer = clone(transformer)
407 # Fit or load from cache the current transformer
--> 408 X, fitted_transformer = fit_transform_one_cached(
409 cloned_transformer,
410 X,
411 y,
412 None,
413 message_clsname="Pipeline",
414 message=self._log_message(step_idx),
415 params=routed_params[name],
416 )
417 # Replace the transformer of the step with the fitted
418 # transformer. This is necessary when loading the transformer
419 # from the cache.
420 self.steps[step_idx] = (name, fitted_transformer)

File ~\anaconda3\envs\ml_testing\lib\site-packages\joblib\memory.py:312, in NotMemorizedFunc.call(self, *args, **kwargs)
311 def call(self, *args, **kwargs):
--> 312 return self.func(*args, **kwargs)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\pipeline.py:1303, in _fit_transform_one(transformer, X, y, weight, message_clsname, message, params)
1301 with _print_elapsed_time(message_clsname, message):
1302 if hasattr(transformer, "fit_transform"):
-> 1303 res = transformer.fit_transform(X, y, **params.get("fit_transform", {}))
1304 else:
1305 res = transformer.fit(X, y, **params.get("fit", {})).transform(
1306 X, **params.get("transform", {})
1307 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\utils_set_output.py:273, in _wrap_method_output..wrapped(self, X, *args, **kwargs)
271 @wraps(f)
272 def wrapped(self, X, *args, **kwargs):
--> 273 data_to_wrap = f(self, X, *args, **kwargs)
274 if isinstance(data_to_wrap, tuple):
275 # only wrap the first output for cross decomposition
276 return_tuple = (
277 _wrap_data_with_container(method, data_to_wrap[0], X, self),
278 *data_to_wrap[1:],
279 )

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\base.py:1351, in _fit_context..decorator..wrapper(estimator, *args, **kwargs)
1344 estimator._validate_params()
1346 with config_context(
1347 skip_parameter_validation=(
1348 prefer_skip_nested_validation or global_skip_validation
1349 )
1350 ):
-> 1351 return fit_method(estimator, *args, **kwargs)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\preprocessing_data.py:3242, in PowerTransformer.fit_transform(self, X, y)
3224 @_fit_context(prefer_skip_nested_validation=True)
3225 def fit_transform(self, X, y=None):
3226 """Fit PowerTransformer to X, then transform X.
3227
3228 Parameters
(...)
3240 Transformed data.
3241 """
-> 3242 return self._fit(X, y, force_transform=True)

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\preprocessing_data.py:3274, in PowerTransformer.fit(self, X, y, force_transform)
3271 self.lambdas[i] = 1.0
3272 continue
-> 3274 self.lambdas_[i] = optim_function(col)
3276 if self.standardize or force_transform:
3277 X[:, i] = transform_function(X[:, i], self.lambdas_[i])

File ~\anaconda3\envs\ml_testing\lib\site-packages\sklearn\preprocessing_data.py:3463, in PowerTransformer._yeo_johnson_optimize(self, x)
3461 x = x[~np.isnan(x)]
3462 # choosing bracket -2, 2 like for boxcox
-> 3463 return optimize.brent(_neg_log_likelihood, brack=(-2, 2))

File ~\anaconda3\envs\ml_testing\lib\site-packages\scipy\optimize_optimize.py:2730, in brent(func, args, brack, tol, full_output, maxiter)
2658 """
2659 Given a function of one variable and a possible bracket, return
2660 a local minimizer of the function isolated to a fractional precision
(...)
2726
2727 """
2728 options = {'xtol': tol,
2729 'maxiter': maxiter}
-> 2730 res = _minimize_scalar_brent(func, brack, args, **options)
2731 if full_output:
2732 return res['x'], res['fun'], res['nit'], res['nfev']

File ~\anaconda3\envs\ml_testing\lib\site-packages\scipy\optimize_optimize.py:2767, in _minimize_scalar_brent(func, brack, args, xtol, maxiter, disp, **unknown_options)
2764 brent = Brent(func=func, args=args, tol=tol,
2765 full_output=True, maxiter=maxiter, disp=disp)
2766 brent.set_bracket(brack)
-> 2767 brent.optimize()
2768 x, fval, nit, nfev = brent.get_result(full_output=True)
2770 success = nit < maxiter and not (np.isnan(x) or np.isnan(fval))

File ~\anaconda3\envs\ml_testing\lib\site-packages\scipy\optimize_optimize.py:2537, in Brent.optimize(self)
2534 def optimize(self):
2535 # set up for optimization
2536 func = self.func
-> 2537 xa, xb, xc, fa, fb, fc, funcalls = self.get_bracket_info()
2538 _mintol = self._mintol
2539 _cg = self._cg

File ~\anaconda3\envs\ml_testing\lib\site-packages\scipy\optimize_optimize.py:2506, in Brent.get_bracket_info(self)
2504 xa, xb, xc, fa, fb, fc, funcalls = bracket(func, args=args)
2505 elif len(brack) == 2:
-> 2506 xa, xb, xc, fa, fb, fc, funcalls = bracket(func, xa=brack[0],
2507 xb=brack[1], args=args)
2508 elif len(brack) == 3:
2509 xa, xb, xc = brack

File ~\anaconda3\envs\ml_testing\lib\site-packages\scipy\optimize_optimize.py:3136, in bracket(func, xa, xb, args, grow_limit, maxiter)
3134 e = BracketError(msg)
3135 e.data = (xa, xb, xc, fa, fb, fc, funcalls)
-> 3136 raise e
3138 return xa, xb, xc, fa, fb, fc, funcalls

BracketError: The algorithm terminated without finding a valid bracket. Consider trying different initial points.

[LeoGrin]

Thanks @Mccti078! This issue is currently reported at #183