R Academy · Lección

Entrenamiento, validación y prevención del sobreajuste

Supervise val_loss, aplique Dropout y use callbacks para la detención temprana.

Lección 4 de 413 pasos

Entrenamiento, validación y prevención del sobreajuste es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

División en entrenamiento, validación y prueba

El aprendizaje profundo requiere tres particiones de datos: entrenamiento (el modelo aprende los parámetros), validación (se supervisa la generalización durante el entrenamiento y se ajustan los hiperparámetros) y prueba (evaluación final imparcial). El argumento validation_split de fit() crea automáticamente el conjunto de validación.

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

El objeto de historial de entrenamiento

El objeto que devuelve fit() contiene una lista $metrics con una entrada por cada métrica registrada en cada época. Llame a plot(history) para visualizar las curvas de entrenamiento y validación una junto a la otra. Las curvas divergentes (el entrenamiento mejora y la validación se estanca) indican 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')

Detección del sobreajuste

El sobreajuste ocurre cuando la pérdida de entrenamiento continúa disminuyendo, pero la pérdida de validación empieza a aumentar. El modelo memoriza los datos de entrenamiento en lugar de aprender patrones generalizables. Signos habituales: una gran diferencia entre la precisión de entrenamiento y validación, y una pérdida de validación que alcanza un mínimo visible y después 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 data

callback_early_stopping()

callback_early_stopping(monitor, patience, restore_best_weights) detiene el entrenamiento cuando la métrica supervisada deja de mejorar. patience es el número de épocas que se espera después de la última mejora. Establezca restore_best_weights = TRUE para volver automáticamente a los pesos de la mejor é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()

Cuando el entrenamiento se estanca, reducir la tasa de aprendizaje suele reactivar el progreso. callback_reduce_lr_on_plateau(monitor, factor, patience) multiplica la tasa de aprendizaje actual por factor cuando la métrica supervisada no ha mejorado 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) guarda los pesos del modelo en el disco al final de cada época (o solo cuando mejora el rendimiento con save_best_only = TRUE). Esto protege frente a interrupciones del entrenamiento y permite cargar el mejor modelo aunque el entrenamiento continúe más allá del punto óptimo.

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 frente a validation_split

validation_split toma el último N % de los datos de entrenamiento. Si los datos están ordenados (por ejemplo, una serie temporal), esto introduce un sesgo. Use validation_data = list(x_val, y_val) en su lugar para proporcionar un conjunto de validación creado previamente a partir de una división aleatoria estratificada.

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

Efecto del tamaño del lote

El tamaño del lote es un hiperparámetro de entrenamiento fundamental. Los lotes más pequeños introducen más ruido en las estimaciones del gradiente (lo que actúa como regularización) y favorecen la generalización. Los lotes más grandes son más rápidos, pero pueden converger hacia mínimos más pronunciados y menos generalizables. Valores habituales: 32, 64 y 128. Pruebe primero con 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')
}

Calentamiento de la tasa de aprendizaje

Comenzar con una tasa de aprendizaje muy pequeña y aumentarla gradualmente durante las primeras épocas (warmup) puede estabilizar el entrenamiento, especialmente en modelos grandes o conjuntos de datos pequeños. Una callback personalizada LearningRateScheduler permite aplicar este patrón.

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

Resumen de la regularización

Para lograr un aprendizaje profundo robusto, combine varias técnicas de regularización:

Dropout: establece aleatoriamente neuronas en cero durante el entrenamiento.
Decaimiento de pesos (L2): penaliza los pesos grandes en la pérdida.
Parada temprana: detiene el entrenamiento antes de que el modelo se sobreajuste.
Aumento de datos: incrementa artificialmente el tamaño del conjunto de entrenamiento.
Normalización por lotes: estabiliza las activaciones y reduce el desplazamiento de covariables.

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

Representación gráfica de las curvas de entrenamiento

Visualice siempre las métricas de entrenamiento y validación una junto a la otra. Un modelo bien entrenado debe mostrar ambas curvas convergiendo y manteniéndose próximas. Si divergen, añada regularización o reduzca la capacidad del modelo. Si ambas curvas se estancan con una pérdida alta, el modelo presenta 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')

Comprobación rápida

¿Qué hace establecer restore_best_weights = TRUE en callback_early_stopping()?

Responde en la lección interactiva

Repaso del entrenamiento y el sobreajuste

Conceptos clave del entrenamiento, la validación y la prevención del sobreajuste:

Use validation_split o validation_data para supervisar la generalización durante el entrenamiento.
plot(history) visualiza las curvas de entrenamiento; las curvas divergentes indican sobreajuste.
callback_early_stopping(patience, restore_best_weights=TRUE) detiene el entrenamiento en la época óptima.
callback_reduce_lr_on_plateau() reduce la tasa de aprendizaje cuando el progreso se estanca.
callback_model_checkpoint(save_best_only=TRUE) guarda el mejor modelo en el disco.
Combine dropout, regularización L2, normalización por lotes y aumento de datos para lograr un entrenamiento 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
)

Gratis para empezar

Aprende R con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 43
Lecciones: 159

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Entrenamiento, validación y prevención del sobreajuste» es gratis?

Sí — el texto completo de «Entrenamiento, validación y prevención del sobreajuste» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Entrenamiento, validación y prevención del sobreajuste»?

Supervise val_loss, aplique Dropout y use callbacks para la detención temprana. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Entrenamiento, validación y prevención del sobreajuste»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Configuración de Keras y TensorFlow en R
Construcción de modelos secuenciales
Fundamentos de las redes neuronales convolucionales
Entrenamiento, validación y prevención del sobreajuste

← Volver a R Academy