Specyfikacje modeli za pomocą parsnip
Określaj typy modeli i silniki niezależnie od etapu trenowania.
Specyfikacje modeli za pomocą parsnip to bezpłatna lekcja R Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.
Czym jest parsnip?
parsnip udostępnia ujednolicony interfejs do setek silników modeli. Zamiast poznawać unikalną składnię każdego pakietu (glm(), randomForest(), e1071::svm()), można napisać jedną spójną specyfikację i wskazać parsnip, którego silnika ma użyć wewnętrznie.
Oznacza to możliwość zamiany silnika — na przykład z glm na stan w bayesowskiej regresji logistycznej — przez zmianę jednego argumentu.
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() do klasyfikacji
logistic_reg() definiuje model regresji logistycznej do klasyfikacji binarnej. Należy połączyć go z set_engine('glm'), aby użyć wbudowanego silnika GLM języka R, oraz z set_mode('classification'), aby jawnie zadeklarować typ zadania.
Tryb ('classification' lub 'regression') jest wymagany w przypadku typów modeli obsługujących oba zadania.
log_spec <- logistic_reg() |>
set_engine('glm') |>
set_mode('classification')
print(log_spec)
# Logistic Regression Model Specification (classification)
# Computational engine: glmrand_forest() z tune()
rand_forest() definiuje model lasu losowego. Parametry takie jak mtry (liczba cech w każdym podziale) i trees można ustawić na stałe albo zastąpić funkcją tune() jako symbolem zastępczym używanym podczas wyszukiwania hiperparametrów.
Po przekazaniu tune() tidymodels przeszuka siatkę wartości podczas dostrajania z użyciem walidacji krzyżowej.
rf_spec <- rand_forest(
mtry = tune(),
trees = 500,
min_n = tune()
) |>
set_engine('ranger', importance = 'impurity') |>
set_mode('classification')
print(rf_spec)linear_reg() do regresji
linear_reg() definiuje model regresji liniowej. Użycie set_engine('lm') oznacza zastosowanie zwykłej metody najmniejszych kwadratów, natomiast set_engine('glmnet') włącza regularyzację L1/L2 za pomocą parametrów penalty i mixture.
# 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() definiuje model drzewa wzmacnianego gradientowo. Można wskazać silnik xgboost, lightgbm lub C5.0. Parametry podlegające dostrajaniu obejmują tree_depth, learn_rate i 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() — trenowanie modelu
fit(spec, formula, data) trenuje specyfikację modelu na rzeczywistych danych. Biblioteka parsnip wewnętrznie tłumaczy specyfikację na odpowiednie wywołanie silnika. Wynikiem jest dopasowany obiekt modelu parsnip.
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() — interfejs macierzowy
fit_xy(spec, x, y) stanowi alternatywę dla fit(spec, formula, data). Przyjmuje bezpośrednio macierz predyktorów x i wektor odpowiedzi y, co jest przydatne, gdy dane zostały już wstępnie przetworzone do macierzy numerycznej (często w przypadku sieci neuronowych lub 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() — wyświetlanie kodu silnika
translate(spec) pokazuje dokładnie, co parsnip wywoła wewnętrznie dla danego silnika. Jest to niezwykle przydatne podczas debugowania lub analizowania, jak specyfikacja parsnip jest mapowana na natywny interfejs silnika.
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() w parsnip
Wszystkie dopasowane modele parsnip korzystają z tego samego interfejsu predict(). W klasyfikacji type = 'class' zwraca przewidywaną klasę, a type = 'prob' zwraca prawdopodobieństwa klas. Ta spójność jest jedną z głównych zalet 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() — dołączanie predykcji do danych
augment(fitted_model, new_data) dołącza kolumny z predykcjami bezpośrednio do wejściowej ramki danych. Jest to wygodne podczas oceny: wynik zawiera obok siebie zarówno prawdziwe wartości, jak i predykcje, dzięki czemu można od razu obliczać metryki.
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')])Porównywanie specyfikacji modeli
Jedną z głównych zalet parsnip jest szybkie porównywanie modeli. Definiuje Pan/Pani wiele specyfikacji, dopasowuje je do tych samych danych i porównuje metryki. Ponieważ interfejs pozostaje identyczny, zamiana modelu wymaga zmiany wyłącznie definicji specyfikacji.
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)Szybkie sprawdzenie
Co zwraca translate(spec) w parsnip?
Podsumowanie parsnip
Najważniejsze informacje z lekcji Specyfikacje modeli w parsnip:
- parsnip udostępnia ujednolicony interfejs: typ modelu, silnik i tryb określa się osobno.
set_engine()wybiera bazowy pakiet, aset_mode()wybiera klasyfikację lub regresję.- Należy używać
tune()jako symbolu zastępczego dla hiperparametrów, które zostaną później przeszukane. fit(spec, formula, data)trenuje model, afit_xy(spec, x, y)przyjmuje macierze.predict(fit, new_data, type)działa spójnie we wszystkich silnikach.translate(spec)pokazuje wywołanie silnika, co ułatwia debugowanie.augment(fit, new_data)dołącza predykcje do ramki danych.
# 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)Często zadawane pytania
Czy lekcja „Specyfikacje modeli za pomocą parsnip” jest bezpłatna?
Tak — pełny tekst „Specyfikacje modeli za pomocą parsnip” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Specyfikacje modeli za pomocą parsnip”?
Określaj typy modeli i silniki niezależnie od etapu trenowania. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć R Academy?
Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Specyfikacje modeli za pomocą parsnip”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?
Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Inżynieria cech za pomocą recipes
- Specyfikacje modeli za pomocą parsnip
- Workflowy: łączenie recipes i modeli
- Próbkowanie i walidacja krzyżowa za pomocą rsample