Spécifications des modèles avec parsnip
Indiquez les types de modèles et les moteurs indépendamment de l’étape d’entraînement.
Spécifications des modèles avec parsnip est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 que parsnip ?
parsnip fournit une interface unifiée vers des centaines de moteurs de modèles. Au lieu d’apprendre la syntaxe propre à chaque paquet (glm(), randomForest(), e1071::svm()), vous écrivez une seule spécification cohérente et indiquez à parsnip quel moteur utiliser en arrière-plan.
Vous pouvez ainsi changer de moteur — par exemple passer de glm à stan pour une régression logistique bayésienne — en modifiant un seul argument.
library(parsnip)
# The same interface, different engines
logistic_reg() |> set_engine('glm') # base R
logistic_reg() |> set_engine('glmnet') # regularized
logistic_reg() |> set_engine('stan') # Bayesianlogistic_reg() pour la classification
logistic_reg() spécifie un modèle de régression logistique pour la classification binaire. Ajoutez set_engine('glm') pour utiliser le moteur GLM intégré à R, et set_mode('classification') pour déclarer explicitement le type de tâche.
Le mode ('classification' ou 'regression') est obligatoire pour les types de modèles qui prennent en charge les deux.
log_spec <- logistic_reg() |>
set_engine('glm') |>
set_mode('classification')
print(log_spec)
# Logistic Regression Model Specification (classification)
# Computational engine: glmrand_forest() avec tune()
rand_forest() spécifie une forêt aléatoire. Des paramètres comme mtry (nombre de variables par division) et trees peuvent être fixés ou définis avec tune() comme emplacement réservé pour la recherche d’hyperparamètres.
Lorsque vous transmettez tune(), tidymodels effectue une recherche sur une grille de valeurs pendant l’ajustement par validation croisée.
rf_spec <- rand_forest(
mtry = tune(),
trees = 500,
min_n = tune()
) |>
set_engine('ranger', importance = 'impurity') |>
set_mode('classification')
print(rf_spec)linear_reg() pour la régression
linear_reg() spécifie un modèle de régression linéaire. L'utilisation de set_engine('lm') applique la méthode des moindres carrés ordinaires, tandis que set_engine('glmnet') active la régularisation L1/L2 au moyen des paramètres de pénalisation et de mélange.
# OLS linear regression
lm_spec <- linear_reg() |>
set_engine('lm')
# Ridge regression (penalty > 0, mixture = 0)
ridge_spec <- linear_reg(penalty = 0.01, mixture = 0) |>
set_engine('glmnet')
# Lasso (penalty > 0, mixture = 1)
lasso_spec <- linear_reg(penalty = tune(), mixture = 1) |>
set_engine('glmnet')boost_tree() — Boosting par gradient
boost_tree() spécifie un modèle d'arbre utilisant le boosting par gradient. Vous pouvez cibler le moteur xgboost, lightgbm ou C5.0. Les paramètres réglables comprennent tree_depth, learn_rate et loss_reduction.
xgb_spec <- boost_tree(
trees = 500,
tree_depth = tune(),
learn_rate = tune(),
loss_reduction = tune()
) |>
set_engine('xgboost') |>
set_mode('classification')
print(xgb_spec)fit() — Entraîner le modèle
fit(spec, formula, data) entraîne la spécification du modèle sur des données réelles. En interne, parsnip traduit la spécification en appel du moteur approprié. Le résultat est un objet de modèle parsnip ajusté.
lm_spec <- linear_reg() |> set_engine('lm')
# Fit the model on training data
lm_fit <- fit(lm_spec, mpg ~ wt + hp + cyl, data = mtcars)
# The fitted object wraps the engine result
print(lm_fit)
# Access the underlying lm object
extract_fit_engine(lm_fit)fit_xy() — Interface matricielle
fit_xy(spec, x, y) constitue une alternative à fit(spec, formula, data). Cette fonction accepte directement une matrice de prédicteurs x et un vecteur de réponses y, ce qui est utile lorsque vos données sont déjà prétraitées sous forme de matrice numérique, comme c'est souvent le cas avec les réseaux neuronaux ou XGBoost.
x_train <- train_baked |> select(-price)
y_train <- train_baked$price
lm_spec <- linear_reg() |> set_engine('lm')
# Matrix-style fit
lm_fit_xy <- fit_xy(lm_spec, x = x_train, y = y_train)
print(lm_fit_xy)translate() — Voir le code du moteur
translate(spec) vous montre exactement ce que parsnip appellera en interne pour un moteur donné. C'est très utile pour déboguer ou comprendre comment votre spécification parsnip est convertie vers l'interface native du moteur.
rf_spec <- rand_forest(mtry = 3, trees = 500) |>
set_engine('ranger') |>
set_mode('classification')
# See what ranger() call will be generated
translate(rf_spec)
# ranger::ranger(formula = ..., data = ...,
# num.trees = 500, mtry = 3, ...)predict() avec parsnip
Tous les modèles parsnip ajustés partagent la même interface predict(). Pour la classification, type = 'class' renvoie la classe prédite et type = 'prob' renvoie les probabilités des classes. Cette cohérence constitue l'un des principaux avantages de parsnip.
log_fit <- fit(logistic_reg() |> set_engine('glm') |> set_mode('classification'),
species ~ ., data = train_df)
# Predicted classes
predict(log_fit, new_data = test_df, type = 'class')
# Predicted probabilities
predict(log_fit, new_data = test_df, type = 'prob')augment() — Prédictions jointes aux données
augment(fitted_model, new_data) ajoute directement les colonnes de prédictions à la trame de données d'entrée. C'est pratique pour l'évaluation : le résultat contient côte à côte les vraies valeurs et les prédictions, prêtes pour le calcul des métriques.
log_fit <- fit(
logistic_reg() |> set_engine('glm') |> set_mode('classification'),
species ~ ., data = train_df
)
# Get predictions joined to test data
results <- augment(log_fit, new_data = test_df)
head(results[, c('species', '.pred_class', '.pred_setosa')])Comparer les spécifications de modèles
L'un des principaux avantages de parsnip est de permettre une comparaison rapide des modèles. Vous définissez plusieurs spécifications, vous les ajustez toutes sur les mêmes données, puis vous comparez les métriques. Comme l'interface est identique, changer de modèle ne nécessite de modifier que la définition de la spécification.
specs <- list(
lm = linear_reg() |> set_engine('lm'),
ridge = linear_reg(penalty = 0.01, mixture = 0) |> set_engine('glmnet'),
rf = rand_forest(trees = 200) |> set_engine('ranger') |> set_mode('regression')
)
fits <- lapply(specs, fit, mpg ~ ., data = train_mtcars)
preds <- lapply(fits, predict, new_data = test_mtcars)
rmse_vals <- sapply(preds, function(p) {
sqrt(mean((p$.pred - test_mtcars$mpg)^2))
})
print(rmse_vals)Vérification rapide
Dans parsnip, que renvoie translate(spec) ?
Récapitulatif de parsnip
Points essentiels sur les spécifications de modèles avec parsnip :
- parsnip fournit une interface unifiée : vous spécifiez séparément le type de modèle, le moteur et le mode.
set_engine()sélectionne le paquet sous-jacent ;set_mode()sélectionne la classification ou la régression.- Utilisez
tune()comme espace réservé pour les hyperparamètres à rechercher ultérieurement. fit(spec, formula, data)entraîne le modèle ;fit_xy(spec, x, y)accepte des matrices.predict(fit, new_data, type)fonctionne de manière cohérente avec tous les moteurs.translate(spec)affiche l'appel du moteur à des fins de débogage.augment(fit, new_data)ajoute les prédictions à la trame de données.
# Parsnip model comparison template
spec <- rand_forest(trees = 500, mtry = tune()) |>
set_engine('ranger', importance = 'impurity') |>
set_mode('classification')
print(translate(spec))
# When mtry is fixed:
spec_fixed <- rand_forest(trees = 500, mtry = 5) |>
set_engine('ranger') |>
set_mode('classification')
fit_fixed <- fit(spec_fixed, label ~ ., data = train_df)
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 « Spécifications des modèles avec parsnip » est-elle gratuite ?
Oui — le texte complet de « Spécifications des modèles avec parsnip » 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 « Spécifications des modèles avec parsnip » ?
Indiquez les types de modèles et les moteurs indépendamment de l’étape d’entraînement. 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 2 sur 4.
Combien de temps prend la leçon « Spécifications des modèles avec parsnip » ?
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