R Academy · Lektion

Modellspezifikationen mit parsnip

Legen Sie Modelltypen und Engines unabhängig vom Trainingsschritt fest

Modellspezifikationen mit parsnip ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist parsnip?

parsnip stellt eine einheitliche Schnittstelle zu Hunderten von Modell-Engines bereit. Statt die einzigartige Syntax jedes Pakets (glm(), randomForest(), e1071::svm()) zu erlernen, schreiben Sie eine einheitliche Spezifikation und teilen parsnip mit, welche Engine im Hintergrund verwendet werden soll.

Dadurch können Sie Engines austauschen – beispielsweise glm durch stan für eine logistische Regression mit Bayes-Ansatz –, indem Sie ein Argument ändern.

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')   # Bayesian

logistic_reg() für Klassifikation

logistic_reg() definiert ein logistisches Regressionsmodell für die binäre Klassifikation. Verketten Sie set_engine('glm'), um die integrierte GLM-Engine von R zu verwenden, und set_mode('classification'), um den Aufgabentyp explizit anzugeben.

Der Modus ('classification' oder 'regression') ist für Modelltypen erforderlich, die beide unterstützen.

log_spec <- logistic_reg() |>
  set_engine('glm') |>
  set_mode('classification')

print(log_spec)
# Logistic Regression Model Specification (classification)
# Computational engine: glm

rand_forest() mit tune()

rand_forest() definiert einen Random Forest. Parameter wie mtry (Anzahl der Merkmale pro Split) und trees können festgelegt oder mit tune() als Platzhalter für die Hyperparametersuche angegeben werden.

Wenn Sie tune() übergeben, durchsucht tidymodels während der Abstimmung per Kreuzvalidierung ein Raster von Werten.

rf_spec <- rand_forest(
  mtry  = tune(),
  trees = 500,
  min_n = tune()
) |>
  set_engine('ranger', importance = 'impurity') |>
  set_mode('classification')

print(rf_spec)

linear_reg() für Regression

linear_reg() definiert ein lineares Regressionsmodell. Mit set_engine('lm') verwenden Sie die gewöhnliche Methode der kleinsten Quadrate, während set_engine('glmnet') über die Parameter penalty und mixture eine L1-/L2-Regularisierung ermöglicht.

# 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() — Gradient Boosting

boost_tree() definiert ein Gradient-Boosting-Baummodell. Sie können die Engine xgboost, lightgbm oder C5.0 verwenden. Zu den abstimmbaren Parametern gehören tree_depth, learn_rate und 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() — Modell trainieren

fit(spec, formula, data) trainiert die Modellspezifikation mit tatsächlichen Daten. parsnip übersetzt die Spezifikation intern in den passenden Aufruf der Engine. Das Ergebnis ist ein angepasstes parsnip-Modellobjekt.

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() — Matrix-Schnittstelle

fit_xy(spec, x, y) ist eine Alternative zu fit(spec, formula, data). Die Funktion akzeptiert direkt eine Prädiktormatrix x und einen Antwortvektor y. Das ist nützlich, wenn Ihre Daten bereits als numerische Matrix vorverarbeitet wurden, wie es bei neuronalen Netzen oder XGBoost häufig der Fall ist.

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() — Engine-Code anzeigen

translate(spec) zeigt genau, welchen Aufruf parsnip für eine bestimmte Engine intern ausführt. Das ist für das Debugging oder zum Verständnis der Zuordnung Ihrer parsnip-Spezifikation zur nativen Schnittstelle der Engine äußerst hilfreich.

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() mit parsnip

Alle angepassten parsnip-Modelle verwenden dieselbe predict()-Schnittstelle. Bei der Klassifikation gibt type = 'class' die vorhergesagte Klasse zurück, während type = 'prob' die Klassenwahrscheinlichkeiten liefert. Diese Einheitlichkeit ist einer der größten Vorteile von 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() — Vorhersagen an Daten anhängen

augment(fitted_model, new_data) hängt die Spalten mit den Vorhersagen direkt an den Eingabedatenrahmen an. Das ist für die Auswertung praktisch: Das Ergebnis enthält sowohl die tatsächlichen Werte als auch die Vorhersagen nebeneinander und ist damit bereit für die Berechnung von Metriken.

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')])

Modellspezifikationen vergleichen

Ein wesentlicher Vorteil von parsnip ist der schnelle Modellvergleich. Sie definieren mehrere Spezifikationen, passen sie alle an dieselben Daten an und vergleichen anschließend die Metriken. Da die Schnittstelle identisch ist, müssen Sie zum Austauschen von Modellen nur die Spezifikationsdefinition ändern.

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)

Kurze Überprüfung

Was gibt translate(spec) in parsnip zurück?

Zusammenfassung zu parsnip

Die wichtigsten Erkenntnisse aus „Modellspezifikationen mit parsnip“:

parsnip stellt eine einheitliche Schnittstelle bereit: Sie legen Modelltyp, Engine und Modus getrennt fest.
set_engine() wählt das zugrunde liegende Paket aus; set_mode() wählt Klassifikation oder Regression.
Verwenden Sie tune() als Platzhalter für Hyperparameter, die später gesucht werden sollen.
fit(spec, formula, data) trainiert das Modell; fit_xy(spec, x, y) akzeptiert Matrizen.
predict(fit, new_data, type) funktioniert über alle Engines hinweg einheitlich.
translate(spec) zeigt den Engine-Aufruf für das Debugging.
augment(fit, new_data) hängt die Vorhersagen an den Datenrahmen an.

# 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)

Häufig gestellte Fragen

Ist die Lektion „Modellspezifikationen mit parsnip“ kostenlos?

Ja — der vollständige Text von „Modellspezifikationen mit parsnip“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Modellspezifikationen mit parsnip“?

Legen Sie Modelltypen und Engines unabhängig vom Trainingsschritt fest Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Modellspezifikationen mit parsnip“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Feature Engineering mit recipes
Modellspezifikationen mit parsnip
Workflows: Rezepte und Modelle kombinieren
Resampling und Cross-Validation mit rsample

← Zurück zu R Academy