Specifiche dei modelli con parsnip
Specifichi i tipi di modello e i relativi engine indipendentemente dalla fase di addestramento
Specifiche dei modelli con parsnip è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.
Che cos'è parsnip?
parsnip offre un'interfaccia unificata a centinaia di motori di modellazione. Invece di imparare la sintassi specifica di ogni pacchetto (glm(), randomForest(), e1071::svm()), scrive un'unica specifica coerente e indica a parsnip quale motore utilizzare internamente.
Questo significa che può sostituire un motore con un altro, ad esempio glm con stan per la regressione logistica bayesiana, modificando un solo argomento.
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() per la classificazione
logistic_reg() specifica un modello di regressione logistica per la classificazione binaria. Colleghi set_engine('glm') per usare il motore GLM integrato in R e set_mode('classification') per dichiarare esplicitamente il tipo di attività.
La modalità ('classification' o 'regression') è necessaria per i tipi di modello che supportano entrambe.
log_spec <- logistic_reg() |>
set_engine('glm') |>
set_mode('classification')
print(log_spec)
# Logistic Regression Model Specification (classification)
# Computational engine: glmrand_forest() con tune()
rand_forest() specifica una random forest. Parametri come mtry (numero di feature per split) e trees possono essere fissati oppure impostati su tune() come segnaposto per la ricerca degli iperparametri.
Quando passa tune(), tidymodels esegue una ricerca su una griglia di valori durante l'ottimizzazione con convalida incrociata.
rf_spec <- rand_forest(
mtry = tune(),
trees = 500,
min_n = tune()
) |>
set_engine('ranger', importance = 'impurity') |>
set_mode('classification')
print(rf_spec)linear_reg() per la regressione
linear_reg() specifica un modello di regressione lineare. L'uso di set_engine('lm') applica il metodo dei minimi quadrati ordinari, mentre set_engine('glmnet') abilita la regolarizzazione L1/L2 tramite i parametri penalty e 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() specifica un modello ad albero con gradient boosting. È possibile scegliere il motore xgboost, lightgbm o C5.0. Tra i parametri regolabili ci sono tree_depth, learn_rate e 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() — Addestrare il modello
fit(spec, formula, data) addestra la specifica del modello sui dati effettivi. Internamente, parsnip traduce la specifica nella chiamata al motore appropriato. Il risultato è un oggetto modello parsnip addestrato.
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() — Interfaccia a matrice
fit_xy(spec, x, y) è un'alternativa a fit(spec, formula, data). Accetta direttamente una matrice dei predittori x e un vettore di risposta y, risultando utile quando i dati sono già stati preprocessati in una matrice numerica, come accade spesso con le reti neurali o 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() — Visualizzare il codice del motore
translate(spec) mostra esattamente quale chiamata eseguirà parsnip internamente per un determinato motore. È uno strumento prezioso per il debugging o per capire come la specifica parsnip viene mappata sull'interfaccia nativa del motore.
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() con parsnip
Tutti i modelli parsnip addestrati condividono la stessa interfaccia predict(). Nella classificazione, type = 'class' restituisce la classe predetta, mentre type = 'prob' restituisce le probabilità delle classi. Questa uniformità è uno dei principali vantaggi di 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() — Aggiungere le predizioni ai dati
augment(fitted_model, new_data) aggiunge direttamente al data frame di input le colonne contenenti le predizioni. È utile per la valutazione: il risultato contiene affiancati sia i valori effettivi sia le predizioni, pronti per il calcolo delle metriche.
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')])Confrontare le specifiche dei modelli
Uno dei principali vantaggi di parsnip è la rapidità nel confrontare i modelli. Si definiscono più specifiche, le si addestra tutte sugli stessi dati e si confrontano le metriche. Poiché l'interfaccia è identica, per cambiare modello è sufficiente modificare la definizione della specifica.
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)Verifica rapida
In parsnip, che cosa restituisce translate(spec)?
Riepilogo di parsnip
Concetti chiave delle specifiche dei modelli con parsnip:
- parsnip fornisce un'interfaccia unificata: si specificano separatamente il tipo di modello, il motore e la modalità.
set_engine()seleziona il pacchetto sottostante;set_mode()seleziona la classificazione o la regressione.- Usi
tune()come segnaposto per gli iperparametri da ricercare in seguito. fit(spec, formula, data)addestra il modello;fit_xy(spec, x, y)accetta matrici.predict(fit, new_data, type)mantiene un comportamento coerente con tutti i motori.translate(spec)mostra la chiamata al motore per il debugging.augment(fit, new_data)aggiunge le predizioni al data frame.
# 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)
Impara R con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 43
- Lezioni
- 159
Domande Frequenti
La lezione «Specifiche dei modelli con parsnip» è gratuita?
Sì — il testo completo di «Specifiche dei modelli con parsnip» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.
Cosa imparerò in «Specifiche dei modelli con parsnip»?
Specifichi i tipi di modello e i relativi engine indipendentemente dalla fase di addestramento Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare R Academy?
Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Specifiche dei modelli con parsnip»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione R Academy?
Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Feature engineering con recipes
- Specifiche dei modelli con parsnip
- Workflow: combinare ricette e modelli
- Ricampionamento e convalida incrociata con rsample