Feature Engineering with recipes

In tidymodels, a recipe is a blueprint for preprocessing your data. It records the steps needed to transform raw data into model-ready features — without immediately applying them.

The key function is recipe(outcome ~ ., data = train), which defines the formula and the reference dataset used to estimate any statistics needed during preprocessing.

step_normalize(all_numeric_predictors()) centers each numeric predictor to mean 0 and scales it to standard deviation 1. This is essential for algorithms sensitive to feature scale, such as logistic regression, SVM, or neural networks.

The mean and SD are computed from the training set and applied consistently to test data via bake().

step_dummy(all_nominal_predictors()) converts categorical (factor/character) variables into numeric dummy (one-hot encoded) columns. By default it creates k-1 columns for a k-level factor, avoiding perfect multicollinearity.

Use one_hot = TRUE for tree-based models that benefit from full one-hot encoding.

Missing values will cause most model engines to fail. step_impute_median(all_numeric_predictors()) replaces NA values with the median computed from the training set. The median is robust to outliers compared to mean imputation.

For categorical variables, use step_impute_mode() to fill with the most frequent value.

step_zv(all_predictors()) removes any predictor that has only a single unique value (zero variance). Such columns carry no information and can cause errors in some model engines.

For near-zero variance, use step_nzv(all_predictors()), which also removes columns where one value dominates overwhelmingly.

prep(recipe) estimates all the parameters required by the steps — for example, the mean/SD for normalization, medians for imputation — using the training data. The result is a prepped recipe that knows all the transformation parameters.

Always prep on training data only to avoid data leakage from the test set.

bake(prepped_recipe, new_data = test_data) applies all preprocessing steps using the already-estimated parameters to any dataset. This ensures transformations are consistent between training and test.

Pass new_data = NULL to apply to the training data that was used during prep().

juice(prepped_recipe) is a convenience function equivalent to bake(prepped_recipe, new_data = NULL). It returns the preprocessed version of the training data that was used during prep().

Note: juice() is slightly deprecated in favour of bake(prep, new_data = NULL), but you will see it in older tidymodels code.

Steps are applied in the order they are added. A typical production recipe follows this order:

1. Imputation (fix NAs first)
2. Feature creation (interactions, polynomials)
3. Dummy encoding (convert factors)
4. Zero-variance removal
5. Normalization (scale at the end)

This ordering matters — for example, normalizing before dummy encoding would produce incorrect results.

After calling prep(), you can inspect what each step did using tidy(prepped_rec). Each step has a numeric id, and you can drill into it with tidy(prepped_rec, number = 1) to see the estimated parameters.

Recipes shine when combined with workflows. Instead of manually calling prep() and bake(), you add the recipe to a workflow and tidymodels handles prep/bake automatically during fit() and predict().

This eliminates a common source of bugs where preprocessing is applied differently at training versus inference time.

What does calling prep(recipe) do in the tidymodels recipes framework?

Key takeaways from Feature Engineering with Recipes:

• recipe(outcome ~ ., data = train) defines the preprocessing blueprint.
• step_normalize(), step_dummy(), step_impute_median(), step_zv() are the most commonly used steps.
• prep() estimates parameters from training data only — never from test data.
• bake(prepped, new_data) applies the trained recipe to any dataset.
• Step order matters: impute → create → encode → remove → scale.
• In production, wrap the recipe in a workflow() to automate prep/bake during fit and predict.