Treinamento, validação e prevenção do sobreajuste
Monitore val_loss, aplique Dropout e use funções de retorno de chamada para a parada antecipada.
Treinamento, validação e prevenção do sobreajuste é 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.
Divisão entre treinamento, validação e teste
O aprendizado profundo exige três partições de dados: treinamento (o modelo aprende os parâmetros), validação (monitora a generalização durante o treinamento e ajusta hiperparâmetros) e teste (avaliação final imparcial). O argumento validation_split em fit() cria o conjunto de validação automaticamente.
# validation_split = 0.2 reserves last 20% as validation
history <- model |> fit(
x_train, y_train,
epochs = 50,
batch_size = 32,
validation_split = 0.2,
verbose = 0
)
# history contains train and val metrics per epoch
names(history$metrics)O objeto de histórico do treinamento
O objeto retornado por fit() contém uma lista $metrics com uma entrada para cada métrica registrada em cada época. Chame plot(history) para visualizar lado a lado as curvas de treinamento e validação. Curvas divergentes (o treinamento melhora, mas a validação se estabiliza) indicam sobreajuste.
# Training loss and accuracy over epochs
head(history$metrics$loss)
head(history$metrics$val_loss)
# Plot training curves
plot(history)
# Or create a custom ggplot
library(ggplot2)
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train = history$metrics$loss,
val = history$metrics$val_loss
)
ggplot(df, aes(epoch)) +
geom_line(aes(y = train, colour = 'Train')) +
geom_line(aes(y = val, colour = 'Validation')) +
labs(y = 'Loss', title = 'Training Curves')Detectando o sobreajuste
O sobreajuste ocorre quando a perda de treinamento continua diminuindo, mas a perda de validação começa a aumentar. O modelo memoriza os dados de treinamento em vez de aprender padrões generalizáveis. Sinais: grande diferença entre a acurácia de treinamento e a de validação; a perda de validação atinge um mínimo visível e depois aumenta.
# Overfitting is visible in the history
# Example of overfitting signatures:
cat('Epoch 5 — Train loss: 0.12, Val loss: 0.18\n')
cat('Epoch 10 — Train loss: 0.06, Val loss: 0.21\n')
cat('Epoch 20 — Train loss: 0.02, Val loss: 0.31\n')
# The model should have stopped at epoch 5!
# Strategies: early stopping, dropout, regularisation, more datacallback_early_stopping()
callback_early_stopping(monitor, patience, restore_best_weights) interrompe o treinamento quando a métrica monitorada deixa de melhorar. patience é o número de épocas a aguardar após a última melhoria. Defina restore_best_weights = TRUE para voltar automaticamente aos pesos da melhor época.
early_stop <- callback_early_stopping(
monitor = 'val_loss',
patience = 10, # wait 10 epochs
restore_best_weights = TRUE # rollback to best
)
history <- model |> fit(
x_train, y_train,
epochs = 200,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop),
verbose = 0
)
cat('Stopped at epoch:', length(history$metrics$loss))callback_reduce_lr_on_plateau()
Quando o treinamento estagna, reduzir a taxa de aprendizado geralmente retoma o progresso. callback_reduce_lr_on_plateau(monitor, factor, patience) multiplica a taxa de aprendizado atual por factor quando a métrica monitorada não melhora durante patience épocas.
reduce_lr <- callback_reduce_lr_on_plateau(
monitor = 'val_loss',
factor = 0.5, # halve the learning rate
patience = 5, # after 5 stagnant epochs
min_lr = 1e-6 # floor for learning rate
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 64,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr),
verbose = 1
)callback_model_checkpoint()
callback_model_checkpoint(filepath, save_best_only) salva os pesos do modelo em disco ao final de cada época (ou somente quando o desempenho melhora, com save_best_only = TRUE). Isso protege contra falhas durante o treinamento e permite carregar o melhor modelo mesmo que o treinamento continue além do ponto ideal.
checkpoint <- callback_model_checkpoint(
filepath = '/tmp/best_model.h5',
monitor = 'val_accuracy',
save_best_only = TRUE,
mode = 'max', # higher accuracy = better
verbose = 1
)
history <- model |> fit(
x_train, y_train,
epochs = 100,
batch_size = 32,
validation_split = 0.2,
callbacks = list(early_stop, reduce_lr, checkpoint)
)
# Reload best model
best_model <- load_model_hdf5('/tmp/best_model.h5')validation_data versus validation_split
validation_split usa os últimos N% dos seus dados de treinamento. Se os dados estiverem ordenados (por exemplo, uma série temporal), isso gera um viés. Em vez disso, use validation_data = list(x_val, y_val) para fornecer um conjunto de validação previamente criado a partir de uma divisão estratificada aleatória.
# Manually create a random validation split
set.seed(42)
val_idx <- sample(nrow(x_train), size = 0.2 * nrow(x_train))
x_val <- x_train[val_idx, ]
y_val <- y_train[val_idx, ]
x_tr <- x_train[-val_idx, ]
y_tr <- y_train[-val_idx, ]
history <- model |> fit(
x_tr, y_tr,
epochs = 50,
batch_size = 32,
validation_data = list(x_val, y_val), # explicit val set
callbacks = list(early_stop)
)Efeito do tamanho do lote
O tamanho do lote é um hiperparâmetro importante do treinamento. Lotes menores introduzem mais ruído nas estimativas do gradiente (atuando como regularização), o que ajuda na generalização. Lotes maiores são mais rápidos, mas podem convergir para mínimos mais acentuados e menos generalizáveis. Valores típicos: 32, 64, 128. Comece com 32.
# Compare training with different batch sizes
for (bs in c(32, 128, 512)) {
set_weights(model, init_weights) # reset
h <- model |> fit(
x_train, y_train,
epochs = 20,
batch_size = bs,
validation_split = 0.2,
verbose = 0
)
cat('Batch:', bs, '| Val Acc:',
tail(h$metrics$val_accuracy, 1), '\n')
}Aquecimento da taxa de aprendizado
Começar com uma taxa de aprendizado muito pequena e aumentá-la gradualmente durante as primeiras épocas (aquecimento) pode estabilizar o treinamento, especialmente em modelos grandes ou conjuntos de dados pequenos. Um retorno de chamada personalizado LearningRateScheduler permite usar esse padrão.
# Custom learning rate schedule with warmup
lr_schedule <- function(epoch, lr) {
if (epoch < 5) {
return(lr * (epoch + 1) / 5) # warmup
} else if (epoch < 30) {
return(lr) # constant
} else {
return(lr * 0.95) # decay
}
}
lr_callback <- callback_learning_rate_scheduler(lr_schedule)
history <- model |> fit(
x_train, y_train,
epochs = 50,
callbacks = list(lr_callback, early_stop),
validation_split = 0.2
)Resumo da regularização
Para obter um aprendizado profundo robusto, combine várias técnicas de regularização:
- Dropout: zera neurônios aleatoriamente durante o treinamento.
- Decaimento dos pesos (L2): penaliza pesos grandes na perda.
- Parada antecipada: interrompe o treinamento antes que o modelo sofra sobreajuste.
- Aumento de dados: aumenta artificialmente o tamanho do conjunto de treinamento.
- Normalização em lotes: estabiliza as ativações e reduz a mudança de covariáveis.
model <- keras_model_sequential(input_shape = c(784)) |>
layer_dense(512, use_bias = FALSE,
kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.4) |>
layer_dense(256, kernel_regularizer = regularizer_l2(1e-4)) |>
layer_batch_normalization() |>
layer_activation('relu') |>
layer_dropout(0.3) |>
layer_dense(10, activation = 'softmax')
model |> compile('adam', 'categorical_crossentropy', 'accuracy')Representando graficamente as curvas de treinamento
Sempre visualize lado a lado as métricas de treinamento e validação. Um modelo bem treinado deve apresentar as duas curvas convergindo e permanecendo próximas. Se elas divergirem, adicione regularização ou reduza a capacidade do modelo. Se ambas se estabilizarem com perda alta, o modelo estará sofrendo subajuste.
# Detailed training curve plot
df <- data.frame(
epoch = seq_along(history$metrics$loss),
train_loss = history$metrics$loss,
val_loss = history$metrics$val_loss,
train_acc = history$metrics$accuracy,
val_acc = history$metrics$val_accuracy
)
par(mfrow = c(1, 2))
plot(df$epoch, df$train_loss, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Loss', main = 'Loss')
lines(df$epoch, df$val_loss, col = 'red')
legend('topright', c('Train', 'Val'), col = c('blue','red'), lty=1)
plot(df$epoch, df$train_acc, type = 'l', col = 'blue',
xlab = 'Epoch', ylab = 'Accuracy', main = 'Accuracy')
lines(df$epoch, df$val_acc, col = 'red')Verificação rápida
O que definir restore_best_weights = TRUE em callback_early_stopping() faz?
Recapitulação do treinamento e do sobreajuste
Principais conclusões sobre treinamento, validação e prevenção do sobreajuste:
- Use
validation_splitouvalidation_datapara monitorar a generalização durante o treinamento. plot(history)visualiza as curvas de treinamento — curvas divergentes indicam sobreajuste.callback_early_stopping(patience, restore_best_weights=TRUE)interrompe o treinamento na época ideal.callback_reduce_lr_on_plateau()reduz a taxa de aprendizado quando o progresso estagna.callback_model_checkpoint(save_best_only=TRUE)salva o melhor modelo em disco.- Combine dropout, regularização L2, normalização em lotes e aumento de dados para obter um treinamento robusto.
# Best practice training setup
callbacks <- list(
callback_early_stopping(
monitor = 'val_loss', patience = 15,
restore_best_weights = TRUE
),
callback_reduce_lr_on_plateau(
monitor = 'val_loss', factor = 0.5, patience = 5
),
callback_model_checkpoint(
'/tmp/best.h5', monitor = 'val_accuracy',
save_best_only = TRUE
)
)
model |> fit(
x_train, y_train,
epochs = 200, batch_size = 64,
validation_split = 0.2,
callbacks = callbacks, verbose = 0
)Perguntas Frequentes
A aula “Treinamento, validação e prevenção do sobreajuste” é grátis?
Sim — o texto completo de “Treinamento, validação e prevenção do sobreajuste” é 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 “Treinamento, validação e prevenção do sobreajuste”?
Monitore val_loss, aplique Dropout e use funções de retorno de chamada para a parada antecipada. 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 “Treinamento, validação e prevenção do sobreajuste”?
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
- Configurando Keras e TensorFlow no R
- Construindo modelos sequenciais
- Fundamentos das redes neurais convolucionais
- Treinamento, validação e prevenção do sobreajuste