R Academy · Lección

Construcción de modelos secuenciales

Apile capas Dense, aplique funciones de activación y compile el modelo con una función de pérdida y un optimizador.

Construcción de modelos secuenciales es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 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.

El modelo secuencial

Un modelo secuencial es una pila lineal de capas en la que cada capa tiene exactamente un tensor de entrada y un tensor de salida. Es el tipo de modelo más sencillo de Keras y cubre la mayoría de los casos de uso prácticos: clasificadores feedforward, regresores y CNN/RNN básicas.

library(keras)

# An empty sequential model
model <- keras_model_sequential()
print(model)

# Or specify the input shape upfront
model <- keras_model_sequential(input_shape = c(20))
print(model)

layer_dense() — Capa totalmente conectada

layer_dense(units, activation) añade una capa totalmente conectada (densa) en la que cada neurona de entrada se conecta con todas las neuronas de salida. El argumento units establece la dimensionalidad de salida. activation aplica una no linealidad: 'relu' es la opción estándar para las capas ocultas.

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(units = 128, activation = 'relu') |>
  layer_dense(units = 64,  activation = 'relu') |>
  layer_dense(units = 1,   activation = 'sigmoid')

# Print architecture
summary(model)

Funciones de activación de la capa de salida

La función de activación de la capa final depende de la tarea:

'sigmoid': clasificación binaria (produce una probabilidad entre 0 y 1)
'softmax': clasificación multiclase (produce probabilidades cuya suma es 1)
'linear' o ninguna activación: regresión (produce predicciones con valores reales)

# Binary classification
binary_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'sigmoid')   # P(class=1)

# Multi-class (10 classes)
multi_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64,  activation = 'relu') |>
  layer_dense(10,  activation = 'softmax')  # P per class

# Regression
reg_model <- keras_model_sequential(input_shape = c(20)) |>
  layer_dense(64, activation = 'relu') |>
  layer_dense(1,  activation = 'linear')   # raw value

compile() — Pérdida, optimizador y métricas

compile(loss, optimizer, metrics) configura el proceso de aprendizaje. Combinaciones habituales:

Binaria: loss = 'binary_crossentropy', metrics = 'accuracy'
Multiclase: loss = 'categorical_crossentropy'
Regresión: loss = 'mse', metrics = 'mae'

model |> compile(
  loss      = 'binary_crossentropy',
  optimizer = optimizer_adam(learning_rate = 0.001),
  metrics   = c('accuracy')
)

# Check configuration
model$loss
model$optimizer$get_config()

optimizer_adam()

Adam (estimación adaptativa de momentos) es el optimizador predeterminado para la mayoría de las tareas de aprendizaje profundo. Adapta la tasa de aprendizaje de cada parámetro utilizando estimaciones del primer y segundo momento de los gradientes. La tasa de aprendizaje predeterminada de 0.001 es un buen punto de partida para la mayoría de los problemas.

# Adam with default settings
model |> compile(
  optimizer = 'adam',
  loss = 'binary_crossentropy',
  metrics = 'accuracy'
)

# Customised Adam
model |> compile(
  optimizer = optimizer_adam(
    learning_rate = 0.0005,
    beta_1  = 0.9,
    beta_2  = 0.999,
    epsilon = 1e-7
  ),
  loss    = 'binary_crossentropy',
  metrics = 'accuracy'
)

fit() — Entrenar el modelo

fit(model, x, y, epochs, batch_size, validation_split) entrena el modelo. Cada época es un recorrido completo por los datos de entrenamiento. El tamaño del lote determina cuántas muestras se procesan antes de cada actualización de los pesos. La función devuelve un objeto de historial.

# Prepare example data
x_train <- matrix(rnorm(1000 * 20), nrow = 1000)
y_train <- sample(c(0, 1), 1000, replace = TRUE)

history <- model |> fit(
  x         = x_train,
  y         = y_train,
  epochs    = 20,
  batch_size = 32,
  validation_split = 0.2,  # reserve 20% for validation
  verbose   = 1
)

plot(history)

Regularización de capas — Dropout

layer_dropout(rate) establece aleatoriamente en 0 una fracción rate de las unidades de entrada durante el entrenamiento. Esto evita que las neuronas se adapten conjuntamente en exceso y actúa como un potente regularizador. Dropout solo está activo durante el entrenamiento, no durante la inferencia.

model <- keras_model_sequential(input_shape = c(784)) |>
  layer_dense(512, activation = 'relu') |>
  layer_dropout(rate = 0.4) |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(rate = 0.3) |>
  layer_dense(10,  activation = 'softmax')

summary(model)

Regularización de pesos L1 y L2

Regularice capas individuales mediante kernel_regularizer para penalizar los pesos grandes. L2 (ridge) penaliza la suma de los pesos al cuadrado; L1 (lasso) penaliza los valores absolutos e induce dispersión. Ambas están disponibles mediante regularizer_l2() y regularizer_l1().

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(
    units = 64,
    activation = 'relu',
    kernel_regularizer = regularizer_l2(l = 0.01)
  ) |>
  layer_dense(
    units = 32,
    activation = 'relu',
    kernel_regularizer = regularizer_l1_l2(l1 = 1e-4, l2 = 1e-3)
  ) |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

Normalización por lotes

layer_batch_normalization() normaliza las activaciones de la capa anterior para cada minilote. Esto estabiliza el entrenamiento, permite utilizar tasas de aprendizaje más altas y actúa como un regularizador moderado. Colóquela después de layer_dense() y antes de la función de activación, o después de la activación; ambas opciones se utilizan en la práctica.

model <- keras_model_sequential(input_shape = c(100)) |>
  layer_dense(256, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(128, use_bias = FALSE) |>
  layer_batch_normalization() |>
  layer_activation('relu') |>
  layer_dense(1, activation = 'sigmoid')

summary(model)

evaluate() y predict()

evaluate(model, x_test, y_test) calcula la pérdida y las métricas con los datos de prueba. predict(model, x_new) genera predicciones sin procesar — probabilidades en el caso de la clasificación. Ambas aceptan matrices numéricas y devuelven valores coherentes y nativos de R.

x_test <- matrix(rnorm(200 * 20), nrow = 200)
y_test <- sample(c(0, 1), 200, replace = TRUE)

# Evaluate on test set
test_metrics <- model |> evaluate(x_test, y_test, verbose = 0)
cat('Test Loss:', test_metrics['loss'])
cat('Test Accuracy:', test_metrics['accuracy'])

# Generate predictions
prob_preds <- model |> predict(x_test)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
table(class_preds, y_test)

Guardar y cargar modelos

Guarde un modelo compilado y entrenado con save_model_tf(model, 'path') (formato TF SavedModel, recomendado) o save_model_hdf5(model, 'model.h5'). Vuelva a cargarlo con load_model_tf() o load_model_hdf5(). El modelo cargado conserva la configuración de compilación y puede realizar predicciones o continuar el entrenamiento inmediatamente.

# Save in TensorFlow SavedModel format (recommended)
save_model_tf(model, '/tmp/my_dense_model')

# Reload
loaded <- load_model_tf('/tmp/my_dense_model')

# Confirm predictions match
new_preds <- loaded |> predict(x_test)
all.equal(prob_preds, new_preds)  # TRUE

Comprobación rápida

Al construir un modelo secuencial para un problema de clasificación de 5 clases, ¿qué función de activación y cuántas unidades debe utilizar la capa de salida?

Repaso de los modelos secuenciales

Conceptos clave de la construcción de modelos secuenciales:

keras_model_sequential() crea una pila lineal de capas.
layer_dense(units, activation) es la capa totalmente conectada fundamental.
Activación de salida: 'sigmoid' (binaria), 'softmax' (multiclase), 'linear' (regresión).
compile(loss, optimizer, metrics) configura el proceso de aprendizaje.
fit(model, x, y, epochs, batch_size, validation_split) entrena el modelo.
Regularización: layer_dropout(rate), regularizer_l2(), layer_batch_normalization().
Guarde con save_model_tf(); cargue con load_model_tf().

library(keras)

model <- keras_model_sequential(input_shape = c(30)) |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(0.4) |>
  layer_dense(64, activation = 'relu') |>
  layer_dropout(0.3) |>
  layer_dense(1, activation = 'sigmoid')

model |> compile(
  optimizer = optimizer_adam(0.001),
  loss      = 'binary_crossentropy',
  metrics   = 'accuracy'
)

history <- model |> fit(
  x_train, y_train,
  epochs = 30, batch_size = 64,
  validation_split = 0.2, verbose = 0
)
plot(history)

Preguntas frecuentes

¿La lección «Construcción de modelos secuenciales» es gratis?

Sí — el texto completo de «Construcción de modelos secuenciales» 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 «Construcción de modelos secuenciales»?

Apile capas Dense, aplique funciones de activación y compile el modelo con una función de pérdida y un optimizador. 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 2 de 4.

¿Cuánto tiempo toma la lección «Construcción de modelos secuenciales»?

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