Reamostragem e validação cruzada com rsample
Avalie modelos com CV de k partes, bootstrap e reamostragem aninhada.
Reamostragem e validação cruzada com rsample é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.
Por que reamostrar?
Uma única divisão entre treinamento e teste fornece uma estimativa ruidosa do desempenho do modelo — você pode ter tido sorte ou azar com as observações que foram parar no conjunto de teste. A reamostragem repete o processo várias vezes para obter uma estimativa estável e confiável de como seu modelo generaliza para novos dados.
library(rsample)
# Single split — performance estimate depends heavily
# on which 20% ended up as test data
split <- initial_split(mtcars, prop = 0.8)
train <- training(split)
test <- testing(split)
cat('Train:', nrow(train), '| Test:', nrow(test))initial_split()
initial_split(data, prop, strata) cria uma única divisão aleatória entre conjuntos de treinamento e teste. Use strata para estratificar por uma coluna, por exemplo, a variável de resposta, garantindo que o equilíbrio entre as classes seja mantido nas duas partições.
library(rsample)
# Stratified split by outcome variable
split <- initial_split(ames, prop = 0.8, strata = Sale_Price)
train <- training(split)
test <- testing(split)
cat('Train rows:', nrow(train))
cat('Test rows:', nrow(test))vfold_cv() — Validação cruzada em K partes
vfold_cv(data, v = 10) cria 10 partes. Os dados são divididos em 10 partes iguais; 9 são usadas para treinamento e 1 para validação, alternando entre todas as partes. Isso produz 10 estimativas de desempenho, cuja média fornece uma métrica estável.
folds <- vfold_cv(housing_train, v = 10, strata = price)
# Each fold is a split object
print(folds)
# Inspect one fold
fold_1 <- folds$splits[[1]]
train_1 <- analysis(fold_1)
val_1 <- assessment(fold_1)
cat('Fold 1 — Train:', nrow(train_1), '| Val:', nrow(val_1))fit_resamples()
fit_resamples(workflow, resamples, metrics) ajusta seu fluxo de trabalho em cada parte de treinamento e o avalia na parte de validação, coletando as métricas solicitadas. Ele retorna uma tabela organizada de resultados que você resume com collect_metrics().
library(tune)
folds <- vfold_cv(housing_train, v = 10)
res <- fit_resamples(
wf, # your workflow
folds,
metrics = metric_set(rmse, rsq)
)
# Average metric across all 10 folds
collect_metrics(res)collect_metrics()
collect_metrics(resample_result) retorna uma tabela organizada que resume o desempenho do modelo em todas as partes. A coluna mean é a média da métrica, e std_err é o erro padrão, ajudando você a perceber a variância da estimativa.
metrics_df <- collect_metrics(res)
print(metrics_df)
# .metric .estimator mean n std_err .config
# rmse standard 24500 10 1200 Preprocessor1_Model1
# rsq standard 0.882 10 0.012 Preprocessor1_Model1
# Pull a single metric
collect_metrics(res) |>
dplyr::filter(.metric == 'rmse') |>
dplyr::pull(mean)bootstraps() — Reamostragem bootstrap
bootstraps(data, times = 25) cria amostras bootstrap: cada amostra é uma seleção aleatória com reposição, do mesmo tamanho do conjunto de dados original. As observações que não foram selecionadas formam o conjunto de avaliação fora da amostra (OOB). O bootstrap apresenta maior variância que o k-fold, mas funciona bem com conjuntos de dados pequenos.
boot_samples <- bootstraps(housing_train, times = 25, strata = price)
print(boot_samples)
# Average proportion of unique rows in each bootstrap
mean(sapply(boot_samples$splits, function(s) {
nrow(analysis(s)) / nrow(housing_train)
}))Validação cruzada de Monte Carlo
mc_cv(data, prop, times) cria times divisões aleatórias, usando prop dos dados para treinamento em cada uma. Diferentemente do k-fold, a mesma observação pode aparecer várias vezes no conjunto de validação. Isso é útil quando você precisa de mais iterações de reamostragem do que o k-fold oferece.
mc_splits <- mc_cv(housing_train, prop = 0.8, times = 20)
res_mc <- fit_resamples(
wf,
mc_splits,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_mc)tune_grid() — Pesquisa de hiperparâmetros
Quando seu fluxo de trabalho contém marcadores tune(), use tune_grid(wf, resamples, grid) para pesquisar uma grade de valores de hiperparâmetros. Cada combinação é avaliada em todas as partes, e a melhor configuração é selecionada com select_best().
rf_spec <- rand_forest(mtry = tune(), trees = tune()) |>
set_engine('ranger') |>
set_mode('regression')
wf_tune <- workflow() |> add_recipe(rec) |> add_model(rf_spec)
grid <- grid_regular(mtry(range = c(2, 10)), trees(range = c(100, 500)), levels = 3)
tune_res <- tune_grid(wf_tune, resamples = folds, grid = grid)
collect_metrics(tune_res) |> head()select_best() e finalize_workflow()
Após o ajuste, select_best(tune_res, metric) escolhe a combinação de hiperparâmetros com a melhor métrica média. finalize_workflow(wf, best_params) cria um novo fluxo de trabalho substituindo tune() por esses valores.
best_params <- select_best(tune_res, metric = 'rmse')
print(best_params)
# Substitute best values into the workflow
final_wf <- finalize_workflow(wf_tune, best_params)
# Fit on all training data, evaluate on test
final_fit <- last_fit(final_wf, split)
collect_metrics(final_fit)Validação cruzada aninhada
Para obter uma avaliação realmente imparcial quando você também ajusta hiperparâmetros, use a validação cruzada aninhada: um ciclo externo para estimar o desempenho e um ciclo interno para o ajuste. No rsample, crie um vfold_cv externo e faça o ajuste dentro de cada parte externa usando as partes internas.
# Outer folds for unbiased evaluation
outer_folds <- vfold_cv(housing_train, v = 5)
# For each outer fold, tune on the inner training data
res_nested <- tune_grid(
wf_tune,
resamples = outer_folds,
grid = 10, # 10 random configurations
metrics = metric_set(rmse)
)
collect_metrics(res_nested)Comparando estratégias de reamostragem
Cada estratégia de reamostragem envolve vantagens e desvantagens. Escolha com base no tamanho do conjunto de dados e no orçamento computacional:
- k-fold (v=10): baixo viés e variância moderada. É a escolha padrão para a maioria dos problemas.
- Bootstrap: funciona com dados muito pequenos; apresenta maior variância que o k-fold.
- CV de Monte Carlo: mais flexível; é uma boa opção para ajustes com restrição de tempo.
- k-fold repetido: menor variância; use quando puder dispor de mais recursos computacionais.
# Repeated k-fold: 5-fold repeated 3 times = 15 models fitted
repeated_folds <- vfold_cv(housing_train, v = 5, repeats = 3)
res_rep <- fit_resamples(
wf,
repeated_folds,
metrics = metric_set(rmse, rsq)
)
collect_metrics(res_rep)Verificação rápida
O que collect_metrics() retorna quando aplicado a um resultado de fit_resamples()?
Recapitulação da reamostragem
Principais conclusões sobre reamostragem e validação cruzada com rsample:
initial_split(data, prop, strata)cria uma divisão estratificada entre treinamento e teste.vfold_cv(data, v = 10)cria partes para validação cruzada em k partes.bootstraps(data, times)cria amostras bootstrap para conjuntos de dados pequenos.fit_resamples(wf, folds, metrics)avalia um fluxo de trabalho em todas as partes.collect_metrics()resume os resultados com a média e o erro padrão.tune_grid()pesquisa hiperparâmetros;select_best()escolhe o vencedor.finalize_workflow()+last_fit()concluem o fluxo de ajuste até a implantação.
# Full rsample pipeline
split <- initial_split(data, prop = 0.8, strata = y)
train <- training(split)
folds <- vfold_cv(train, v = 10)
res <- fit_resamples(wf, folds, metrics = metric_set(rmse, rsq))
collect_metrics(res)
# After tuning
best <- select_best(tune_res, metric = 'rmse')
fin_wf <- finalize_workflow(wf_tune, best)
last_fit(fin_wf, split) |> collect_metrics()Perguntas Frequentes
A aula “Reamostragem e validação cruzada com rsample” é grátis?
Sim — o texto completo de “Reamostragem e validação cruzada com rsample” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.
O que vou aprender em “Reamostragem e validação cruzada com rsample”?
Avalie modelos com CV de k partes, bootstrap e reamostragem aninhada. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar R Academy?
Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Reamostragem e validação cruzada com rsample”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de R Academy?
Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Engenharia de atributos com recipes
- Especificações de modelos com parsnip
- Fluxos de trabalho: combinando receitas e modelos
- Reamostragem e validação cruzada com rsample