Flux de travail : combiner recettes et modèles
Regroupez le prétraitement et le modèle dans un objet de flux de travail unique.
Flux de travail : combiner recettes et modèles est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce qu'un workflow ?
Un workflow regroupe une recette et une spécification de modèle dans un seul objet. Cela résout un problème essentiel : les étapes de prétraitement et de modélisation doivent être traitées comme une seule unité pendant la validation croisée et l'ajustement final, faute de quoi des paramètres comme les moyennes de normalisation peuvent fuir depuis les partitions de test.
library(workflows)
# Start an empty workflow
wf <- workflow()
print(wf)
# Workflows have two slots: preprocessor and model
# Both must be filled before fittingadd_recipe() et add_model()
Utilisez add_recipe(rec) pour associer un préprocesseur de recette et add_model(spec) pour associer une spécification de modèle parsnip. L'opérateur pipe rend cette construction très lisible.
library(recipes)
library(parsnip)
library(workflows)
rec <- recipe(price ~ ., data = train) |>
step_impute_median(all_numeric_predictors()) |>
step_dummy(all_nominal_predictors()) |>
step_normalize(all_numeric_predictors())
spec <- linear_reg() |> set_engine('lm')
wf <- workflow() |>
add_recipe(rec) |>
add_model(spec)
print(wf)fit() sur un workflow
L'appel de fit(wf, data = train) sur un workflow appelle automatiquement prep() sur la recette à l'aide des données d'entraînement, puis entraîne le modèle sur les variables prétraitées. Vous n'avez jamais besoin d'appeler manuellement prep() ou bake().
fitted_wf <- fit(wf, data = housing_train)
# The fitted workflow stores both the prepped recipe
# and the trained model
print(fitted_wf)predict() sur un workflow ajusté
Lorsque vous appelez predict(fitted_wf, new_data = test), le workflow applique automatiquement bake() aux nouvelles données à l'aide de la recette entraînée avant de générer les prédictions. Cela élimine le risque d'oublier de prétraiter les données de test.
# Predictions automatically preprocess the test data
preds <- predict(fitted_wf, new_data = housing_test)
head(preds)
# For classification
preds_prob <- predict(fitted_wf, new_data = test_df, type = 'prob')
preds_class <- predict(fitted_wf, new_data = test_df, type = 'class')last_fit() — Entraîner sur toutes les données, évaluer sur le test
last_fit(wf, split) prend votre workflow final et l'objet de partitionnement initial entre entraînement et test. Il ajuste le workflow sur la partie d'entraînement et l'évalue sur la partie de test — c'est l'étape standard d'évaluation du modèle final une fois le réglage terminé.
library(rsample)
split <- initial_split(housing_data, prop = 0.8, strata = price)
# Fit on training, evaluate on test
final_res <- last_fit(wf, split)
# View performance on the held-out test set
collect_metrics(final_res)extract_fit_parsnip()
extract_fit_parsnip(fitted_wf) extrait l'objet de modèle parsnip entraîné d'un workflow ajusté. Vous pouvez ensuite l'utiliser pour examiner les coefficients, l'importance des variables ou le transmettre à des outils d'explication de modèles.
fitted_wf <- fit(wf, data = housing_train)
# Extract the parsnip model
parsnip_fit <- extract_fit_parsnip(fitted_wf)
# Now access the underlying model
tidy(parsnip_fit) # coefficients for lm
vip::vip(parsnip_fit) # variable importance plotextract_recipe()
extract_recipe(fitted_wf) renvoie la recette préparée d'un workflow ajusté. C'est utile pour examiner les transformations appliquées ou récupérer le prétraitement entraîné afin de l'appliquer indépendamment à des données externes.
fitted_wf <- fit(wf, data = housing_train)
# Get the prepped recipe
prepped_rec <- extract_recipe(fitted_wf)
# Inspect normalization stats
tidy(prepped_rec, number = 3) # step_normalize details
# Apply recipe to completely new external data
new_baked <- bake(prepped_rec, new_data = brand_new_df)augment() sur les workflows
augment(fitted_wf, new_data) renvoie la trame de données d'entrée avec les colonnes de prédictions ajoutées. Pour la régression, la fonction ajoute .pred ; pour la classification, elle ajoute .pred_class et une colonne de probabilités pour chaque classe.
fitted_wf <- fit(wf, data = housing_train)
# Append predictions to the test data frame
results <- augment(fitted_wf, new_data = housing_test)
# Now compute metrics directly
library(yardstick)
results |>
metrics(truth = price, estimate = .pred)Mettre à jour un workflow
Vous pouvez mettre à jour des composants individuels d'un workflow avec update_recipe() ou update_model() sans le reconstruire depuis zéro. C'est pratique pendant les expérimentations, lorsque vous souhaitez changer de moteur de modèle tout en conservant la même recette.
# Original workflow with lm
wf_lm <- workflow() |>
add_recipe(rec) |>
add_model(linear_reg() |> set_engine('lm'))
# Swap model to random forest, keep same recipe
wf_rf <- update_model(
wf_lm,
rand_forest(trees = 300) |>
set_engine('ranger') |>
set_mode('regression')
)
fit_rf <- fit(wf_rf, data = housing_train)add_formula() ou add_recipe()
Si vous n'avez pas besoin d'une recette, vous pouvez utiliser add_formula(outcome ~ .) comme préprocesseur. Cette fonction applique un minimum de transformations, limité à la spécification de la formule. Utilisez add_recipe() si vous avez besoin de créer des variables ; utilisez add_formula() pour des modèles de référence rapides.
# Simple baseline — no recipe needed
baseline_wf <- workflow() |>
add_formula(price ~ sqft + bedrooms + bathrooms) |>
add_model(linear_reg() |> set_engine('lm'))
baseline_fit <- fit(baseline_wf, data = housing_train)
baseline_preds <- predict(baseline_fit, new_data = housing_test)
# Compare RMSE to recipe-based model
yardstick::rmse_vec(housing_test$price, baseline_preds$.pred)Ensembles de workflows pour la comparaison
workflow_set(), issu du paquet workflowsets, crée une collection de workflows combinant plusieurs recettes et spécifications de modèles. Vous pouvez ensuite régler et évaluer toutes les combinaisons en une seule fois avec workflow_map().
library(workflowsets)
all_workflows <- workflow_set(
preproc = list(basic = basic_rec, full = full_rec),
models = list(
lm = linear_reg() |> set_engine('lm'),
rf = rand_forest(trees = 200) |> set_engine('ranger') |> set_mode('regression')
)
)
# Fit all 4 combinations on resamples
results <- workflow_map(all_workflows, 'fit_resamples', resamples = cv_folds)
autoplot(results)Vérification rapide
Quel est le principal avantage d'utiliser last_fit(workflow, split) plutôt que d'effectuer manuellement l'ajustement et les prédictions ?
Récapitulatif des workflows
Points essentiels sur les workflows : combiner recettes et modèles :
workflow() |> add_recipe(rec) |> add_model(spec)regroupe le prétraitement et la modélisation.fit(wf, data = train)prépare la recette et entraîne le modèle en un seul appel.predict(fitted_wf, new_data)applique automatiquementbake()aux nouvelles données avant la prédiction.last_fit(wf, split)entraîne sur les données d'entraînement et évalue sur les données de test : utilisez-le pour l'évaluation finale du modèle.extract_fit_parsnip()etextract_recipe()récupèrent les composants à des fins d'examen.augment()ajoute les prédictions à la trame de données pour faciliter le calcul des métriques.workflow_set()compare simultanément plusieurs combinaisons recette-modèle.
# Canonical tidymodels workflow pattern
split <- initial_split(data, prop = 0.8)
train <- training(split)
test <- testing(split)
rec <- recipe(y ~ ., data = train) |> step_normalize(all_numeric_predictors())
spec <- rand_forest(trees = 300) |> set_engine('ranger') |> set_mode('regression')
wf <- workflow() |> add_recipe(rec) |> add_model(spec)
final_res <- last_fit(wf, split)
collect_metrics(final_res)
Apprends R avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 43
- Leçons
- 159
Questions Fréquemment Posées
La leçon « Flux de travail : combiner recettes et modèles » est-elle gratuite ?
Oui — le texte complet de « Flux de travail : combiner recettes et modèles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Flux de travail : combiner recettes et modèles » ?
Regroupez le prétraitement et le modèle dans un objet de flux de travail unique. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer R Academy ?
Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Flux de travail : combiner recettes et modèles » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon R Academy ?
Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Ingénierie des caractéristiques avec recipes
- Spécifications des modèles avec parsnip
- Flux de travail : combiner recettes et modèles
- Rééchantillonnage et validation croisée avec rsample