Pipeline vs GridSearchCV: Predicting after cross‑validation when refit=False

Short answer

No. With refit=False, GridSearchCV never fits an estimator on the full dataset, so predict() raises NotFittedError and best_estimator_ is None. There is no flag that hands you a usable model from that run. The supported paths are: (1) clone the pipeline, apply best_params_, and fit it yourself, or (2) use cross_val_predict if you only need out-of-fold predictions for evaluation. Using a Pipeline changes nothing here — it is simply the estimator that gets cloned and fitted per fold.

Confirmed behavior vs. reasoning

• Confirmed (stable across scikit-learn 1.x; verify against your installed version): with refit=False, only best_params_, best_score_, and cv_results_ are populated. best_score_ is the mean cross-validated score of the winning parameter set, not a full-data score.
• Confirmed: best_params_ keys already carry step prefixes (e.g., clf__C), so they can be passed straight to the pipeline's set_params().
• Reasoning, not documented: no "retrieve the best fold model" option exists because fold estimators are discarded after scoring. Exposing them would return models trained on subsets of the data — not equivalent to a full-data fit — and keeping all k of them would multiply model memory by the fold count.

Fix: refit the best parameters yourself

from sklearn.base import clone

grid = GridSearchCV(pipe, param_grid, refit=False, cv=5)
grid.fit(X_train, y_train)

# grid.predict(X_test)        # NotFittedError
assert grid.best_estimator_ is None

best_model = clone(grid.estimator).set_params(**grid.best_params_)
best_model.fit(X_train, y_train)
preds = best_model.predict(X_test)

grid.estimator is the original, unfitted pipeline, so cloning it gives a clean slate. The cost of this extra fit is exactly the final fit that refit=True would have run, so total runtime is comparable — you've just made it explicit. One caveat: for estimators with stochastic components, fix random_state, or this manual model may differ slightly from what an internal refit would have produced.

If you wanted out-of-fold predictions instead

If the goal is predictions during cross-validation (e.g., building a stacked feature or evaluating per-sample errors), cross_val_predict is the right tool — but it performs no hyperparameter search, so run it after choosing parameters:

oof = cross_val_predict(
    clone(grid.estimator).set_params(**grid.best_params_),
    X_train, y_train, cv=grid.cv,
)

The result has one prediction per training sample and is valid only for evaluating that cross-validation split — it is not a model and cannot score new data. Also note that reusing grid.cv reproduces the same folds only for deterministic splitters (an int, or KFold without shuffle=True); otherwise fold assignments will differ between runs.

On the memory/computation question

A "best estimator without refitting" cannot exist without changing semantics: a full-data model requires a full-data fit by definition. The only extra memory refit=False saves is the final fitted model; cv_results_ remains and can grow large with many candidates or multi-metric scoring. If you never call predict afterward, refit=False is a genuine saving; if you do, you pay the refit either way, so refit=True is usually simpler.

Quick verification

1. Fit with refit=False and confirm best_estimator_ is None and that predict raises NotFittedError.
2. After the manual refit, compare best_model.score(X_test, y_test) with grid.best_score_ — they should be close but not identical, since best_score_ is a CV mean.

The deciding detail between the two paths is whether predictions must come from a model trained on all data (manual refit) or only describe the CV folds (cross_val_predict) — pick based on which of those you actually need.