tidymodels Exercises in R: 25 Real-World Practice Problems

Explanation: initial_split() returns an rsplit object that simply records row indices, so memory stays cheap. The strata argument bins cut and samples within each bucket so rare levels (Fair, Good) appear in both train and test in roughly their original proportion. Without stratification a random split can leave the test set missing whole levels of an ordered factor, which then breaks predict() downstream.

Explanation: With only 32 rows the analysis set per fold is tiny, which is exactly when k-fold CV beats a single hold-out: each row is used as an assessment point exactly once, smoothing the variance of the performance estimate. Use repeats = 5 if you need even tighter variance bounds. Always set the seed before calling vfold_cv() because the row shuffle is random.

Explanation: Bootstraps draw rows with replacement; the assessment set is the out-of-bag rows for that draw, so its size varies from sample to sample (hence the differing right-hand counts). Stratification ensures each species contributes roughly 50 sampled rows. Bootstraps tend to give optimistic performance estimates compared to k-fold CV because the analysis sets overlap heavily; use them for variance estimation or when sample size is small.

Explanation: Rolling-origin respects time ordering, which random CV would violate by leaking future observations into training folds. With cumulative = FALSE the analysis window is fixed-width (always 120 rows) and slides forward by one step per slice, mimicking how a production forecaster retrains weekly on the most recent year. Set cumulative = TRUE for an expanding window when older history is also informative.

Explanation: A recipe is a deferred plan: it remembers what to do but only computes means and standard deviations when prep() or a workflow fit() is called on training data. Using selectors like all_numeric_predictors() keeps the spec robust to schema changes; you do not have to rewrite the recipe if a new numeric column appears. Centering and scaling matter for penalized regression and distance-based learners.

Explanation: With one_hot = FALSE recipes drops one reference level per factor, the standard treatment for unregularized linear models so the design matrix stays full-rank. Use one_hot = TRUE for tree-based models that do not need a reference level and for L1-penalised models when you want the penalty to choose which level to drop. Step order matters: step_dummy() must come AFTER step_other() if you want to lump rare levels first.

Explanation: step_impute_knn() fills missing cells using the average of the nearest non-missing neighbours in predictor space, which preserves the multivariate structure better than mean imputation. Always impute BEFORE normalising; otherwise the scaler computes a mean on a column with NAs and the imputed cells are scaled against an incorrect centre. step_normalize() is a one-step shortcut for step_center() plus step_scale().

Explanation: Rare levels carry almost no signal but inflate the design matrix and risk leaking labels when the test set sees a level never observed in training. step_other() solves both: anything below the threshold becomes the literal level "other". The threshold can be a proportion (between 0 and 1) or a raw count. Put it strictly before step_dummy(), since dummy expansion happens on the already-lumped factor.

Explanation: Order matters: normalise first so the PCA loadings are not dominated by the column with the largest variance, then create interactions, then PCA the union. step_interact() takes a formula with the colon syntax, so disp:hp means "the product of disp and hp". PCA on the expanded matrix yields uncorrelated components that absorb most of the joint variance, which a downstream OLS or glmnet can consume without multicollinearity warnings.

Explanation: parsnip separates WHAT model you want (a linear regression) from WHICH engine fits it (lm, glmnet, stan, keras, etc.). The model specification is itself a small object that holds no data: it gets fit() later inside a workflow or directly with fit(spec, formula, data). This decoupling is the whole point of parsnip: you can swap engines without rewriting the rest of the pipeline.

Explanation: Marking an argument with tune() is a placeholder: it tells parsnip that the value will be provided later by tune_grid() or tune_bayes(). With mixture = 0 glmnet behaves as pure ridge (L2), with mixture = 1 it is pure lasso (L1), and anything in between is elastic net. Tuning both at once explores the regularization geometry rather than committing to a flavour up front, which usually wins on noisy financial features.

Explanation: logistic_reg() is already a classification-only spec so set_mode("classification") is technically redundant, but writing it explicitly makes the intent obvious in code reviews. The glm engine fits maximum likelihood; switch to glmnet if you need regularization or to stan_glm (via rstanarm) for Bayesian posterior intervals. parsnip will silently route predict(type = "prob") to the correct underlying call.

Explanation: ranger is the production-grade engine: it is multi-threaded, handles factors directly, and is roughly an order of magnitude faster than the original randomForest package on wide data. Keep trees fixed (500 is usually plenty for accuracy stability) and tune mtry and min_n, which control bias/variance trade-off and tree depth. Setting importance = "impurity" on the engine call would let you read feature importance after fitting.

Explanation: A workflow is the single object you pass to fit(), predict(), last_fit(), and tune_grid(). Bundling recipe and spec prevents the classic mistake of preprocessing train and test differently: when you call fit(workflow, train), the recipe is prep()d on train ONLY, and predict(workflow, new_data = test) reuses those frozen statistics. A workflow without a preprocessor is allowed; add a formula instead with add_formula().

Explanation: extract_fit_parsnip() digs through the workflow wrapper and returns the inner parsnip fit object; tidy() then converts the engine-specific coefficient table into a uniform tibble. Use extract_fit_engine() instead if you need the raw lm object for diagnostics. Always tidy the result before plotting or exporting: the column names (estimate, std.error) are guaranteed by broom regardless of engine.

Explanation: workflow_set() takes lists of preprocessors and models and produces every combination as rows of a tibble. You then call workflow_map("fit_resamples", resamples = folds) on the whole set to evaluate them in one call, and rank_results() to sort the leaderboard. This is the right tool when you want to compare three preprocessing variants against four model families: twelve workflows in three lines of code.

Explanation: last_fit() is the bridge between training and the final test-set score. It refits the workflow on the training set, generates predictions on the test set, and returns one tibble row holding the metrics, the predictions, and the fitted workflow. Pull pieces with collect_metrics(), collect_predictions(), or extract_workflow(). Use it once and only once per project: the test set is sacred and not for iteration.

Explanation: grid_regular() builds a Cartesian product across the named parameters. The dials package defines sensible default ranges per parameter: penalty() defaults to 1e-10 to 1 on a log10 scale, and mixture() to 0 to 1 linearly. Override with penalty(range = c(-4, 0)) if you want a tighter window. For higher-dimensional spaces use grid_latin_hypercube() or grid_space_filling(), which scale far better than dense grids.

Explanation: tune_grid() fits the workflow once per (fold x grid point) combination, here 5 x 25 = 125 fits, and returns a nested tibble. collect_metrics() flattens that into one row per (grid point x metric), averaging across folds and reporting the standard error so you can spot which configurations are merely lucky rather than genuinely best. Pass control = control_grid(save_pred = TRUE) if you also want the raw fold predictions for ROC plotting.

Explanation: select_best() returns a one-row tibble with the winning hyperparameter combination by the named metric. finalize_workflow() substitutes those values into every tune() placeholder in the workflow, producing a workflow object that no longer contains any unresolved parameters. From here you call last_fit(ex_5_3, split = your_initial_split) to score the test set, or fit(ex_5_3, data = full_train) for production. Use select_by_one_std_err() for a more conservative pick.

Explanation: tune_bayes() fits a Gaussian process surrogate over the parameter space using the initial points, then proposes the next configuration where the GP expects the largest improvement in the target metric. The no_improve argument is an early-stopping rule: if 5 successive iterations fail to beat the running best, the search halts. For 2-3 dimensional spaces grid search still wins on simplicity, but for 5+ dimensions Bayesian search reaches similar accuracy with 10x fewer fits.

Explanation: metric_set() is a closure factory: it returns a function that accepts a data frame plus truth and estimate columns and returns the metrics as a tidy tibble. Bundling metrics like this is far cleaner than calling rmse(), rsq(), and mae() separately and bind_rows-ing them. The .estimator column distinguishes binary, micro, macro, etc.; for regression it is always standard.

Explanation: yardstick separates class-prediction metrics (need estimate = .pred_class) from probability-based metrics (need the class-prob column, here .pred_yes). A single metric_set() accepts both: pass the class column as estimate and any probability columns as additional unnamed arguments. The event_level argument tells sensitivity which factor level is the positive class; without it yardstick defaults to the first factor level, which is often wrong for "yes/no" outcomes.

Explanation: roc_curve() returns a tibble of thresholds, sensitivity, and specificity at each cut point; autoplot.roc_df() is the yardstick-specific method that renders it with the chance diagonal. Pair it with pr_curve() for the precision-recall view, which is far more informative on imbalanced targets (here the 30/70 churn split is borderline). For a multiclass ROC, pass several prob columns and yardstick produces one curve per class facet.

Explanation: Cohen's kappa adjusts raw accuracy for the proportion of agreement expected by chance, which matters when class frequencies are uneven. A kappa above 0.8 is conventionally "almost perfect"; near zero means the classifier is no better than guessing the marginal proportions. summary(conf_mat) returns roughly 13 metrics in one tibble (accuracy, kappa, sensitivity, specificity, ppv, npv, mcc, f1, and more), which is the fastest way to populate a stakeholder report card.