0Pricing
R Academy · Lección

Fundamentos de las redes neuronales convolucionales

Añada capas Conv2D y MaxPooling para tareas de clasificación de imágenes.

Fundamentos de las redes neuronales convolucionales es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 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.

¿Por qué CNN para imágenes?

Una red densa trata los píxeles de forma independiente y pierde las relaciones espaciales. Una red neuronal convolucional (CNN) aplica filtros entrenables que se deslizan por la entrada y detectan patrones locales, como bordes, texturas y formas, independientemente de su posición. Esta invariancia a la traslación y el uso compartido de parámetros convierten a las CNN en el estándar de referencia para los datos de imágenes.

library(keras)

# Images are 3D tensors: (height, width, channels)
# MNIST: (28, 28, 1) — grayscale
# CIFAR-10: (32, 32, 3) — RGB

# Reshape flat vectors into image tensors
mnist <- dataset_mnist()
x_train <- array_reshape(mnist$train$x / 255, c(-1, 28, 28, 1))
y_train <- to_categorical(mnist$train$y, 10)

cat('Input shape:', dim(x_train))

layer_conv_2d() — La capa fundamental

layer_conv_2d(filters, kernel_size, activation) aplica filters kernels 2D entrenables de tamaño kernel_size a la entrada. Cada filtro aprende a detectar un tipo de patrón espacial. La salida tiene la forma (height, width, filters).

library(keras)

# First conv layer: 32 filters of 3x3
model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(
    filters     = 32,
    kernel_size = c(3, 3),
    activation  = 'relu',
    padding     = 'same'  # keep spatial dimensions
  )

summary(model)  # output: (None, 28, 28, 32)

layer_max_pooling_2d()

layer_max_pooling_2d(pool_size) reduce las dimensiones espaciales tomando el valor máximo en cada ventana de pooling. Esto logra dos objetivos: reduce el número de parámetros de las capas posteriores e introduce cierto grado de invariancia a la traslación (los pequeños desplazamientos no cambian drásticamente la salida).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, kernel_size = c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(pool_size = c(2, 2))

summary(model)
# After pooling: (None, 13, 13, 32)
# Spatial dims halved, channel count preserved

Apilamiento de capas convolucionales

Las CNN más profundas apilan varios bloques Conv+Pool. Las primeras capas detectan características de bajo nivel (bordes y gradientes); las capas más profundas las combinan para formar características de alto nivel (formas y objetos). Cada capa Conv aumenta el número de filtros para compensar la reducción de las dimensiones espaciales.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 16x16
  layer_conv_2d(64, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>   # 8x8
  layer_conv_2d(128, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2))      # 4x4

summary(model)

layer_flatten()

layer_flatten() convierte la salida 3D del último bloque convolucional (height, width, filters) en un vector 1D. Es el puente entre la base de extracción de características (capas convolucionales) y la cabeza de clasificación (capas densas).

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>     # 3D -> 1D vector
  layer_dense(128, activation = 'relu') |>
  layer_dense(10, activation = 'softmax')

summary(model)

layer_dropout() en CNN

En las CNN, el dropout suele aplicarse después de la capa flatten y de las capas densas, no dentro de los bloques convolucionales (donde se prefiere el dropout espacial layer_spatial_dropout_2d()). Es habitual utilizar una tasa de 0.25-0.5 después de la primera capa densa.

model <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_conv_2d(64, c(3, 3), activation = 'relu') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(128, activation = 'relu') |>
  layer_dropout(rate = 0.5) |>    # regularise the classifier head
  layer_dense(10, activation = 'softmax')

summary(model)

Compilación y entrenamiento de una CNN

Compile y entrene una CNN igual que una red densa. Para la clasificación multiclase con etiquetas one-hot, use 'categorical_crossentropy'; para etiquetas enteras, use 'sparse_categorical_crossentropy'. Las CNN suelen beneficiarse de una tasa de aprendizaje ligeramente menor que las redes densas.

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

history <- model |> fit(
  x = x_train,
  y = y_train,
  epochs     = 10,
  batch_size = 64,
  validation_split = 0.1,
  verbose = 1
)

plot(history)

Aumento de datos

Entrenar CNN con conjuntos de datos pequeños suele provocar sobreajuste. El aumento de datos amplía artificialmente el conjunto de entrenamiento aplicando transformaciones aleatorias (volteos, rotaciones y zoom) durante el entrenamiento. En keras3, use layer_random_flip() y layer_random_rotation() como capas de preprocesamiento dentro del modelo.

model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  # Data augmentation layers (only active during training)
  layer_random_flip('horizontal') |>
  layer_random_rotation(factor = 0.1) |>
  layer_random_zoom(height_factor = 0.1) |>
  # CNN backbone
  layer_conv_2d(32, c(3, 3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2, 2)) |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')

summary(model)

Evaluación de la CNN

evaluate(model, x_test, y_test) devuelve la pérdida y la precisión en los datos de prueba. Para un análisis más detallado, use predict() para obtener las probabilidades de clase y, después, construya una matriz de confusión o calcule las puntuaciones F1 por clase para comprender en qué aspectos tiene dificultades el modelo.

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

# Get predicted classes
prob_matrix <- model |> predict(x_test)
pred_classes <- max.col(prob_matrix) - 1  # 0-indexed
true_classes <- mnist$test$y

# Confusion matrix
table(Predicted = pred_classes, True = true_classes)

Concepto de aprendizaje por transferencia

Entrenar una CNN desde cero requiere conjuntos de datos grandes. El aprendizaje por transferencia reutiliza capas de extracción de características preentrenadas con ImageNet (por ejemplo, VGG, ResNet y MobileNet) y solo entrena una cabeza de clasificación personalizada. En keras, cargue una base preentrenada con application_mobilenet_v2() y congele sus capas.

# Load MobileNetV2 pretrained on ImageNet
base_model <- application_mobilenet_v2(
  weights      = 'imagenet',
  include_top  = FALSE,          # remove original classifier head
  input_shape  = c(224, 224, 3)
)

# Freeze pretrained weights
base_model$trainable <- FALSE

# Add custom classifier head
model <- keras_model(
  inputs  = base_model$input,
  outputs = base_model$output |>
    layer_global_average_pooling_2d() |>
    layer_dense(128, activation = 'relu') |>
    layer_dense(5, activation = 'softmax')
)

Relleno y strides de Conv2D

Dos argumentos importantes de layer_conv_2d: padding = 'same' añade ceros alrededor de la entrada para que la salida tenga el mismo tamaño espacial que la entrada; padding = 'valid' (predeterminado) reduce las dimensiones en kernel_size - 1. strides = c(2,2) sustituye el max pooling al deslizar el filtro en pasos de 2.

# 'same' padding: output = input size
conv_same <- layer_conv_2d(filters = 32, kernel_size = c(3, 3),
                           padding = 'same')

# Strided convolution instead of pooling
conv_strided <- layer_conv_2d(filters = 64, kernel_size = c(3, 3),
                              strides = c(2, 2),  # halves spatial dims
                              padding = 'same')

# Model using strides instead of max pooling
model2 <- keras_model_sequential(input_shape = c(28, 28, 1)) |>
  layer_conv_2d(32, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_conv_2d(64, c(3,3), strides = c(2,2), activation = 'relu',
                padding = 'same') |>
  layer_flatten() |>
  layer_dense(10, activation = 'softmax')
summary(model2)

Comprobación rápida

¿Cuál es la finalidad principal de layer_max_pooling_2d(pool_size = c(2, 2)) en una CNN?

Repaso de las CNN

Conceptos clave de los fundamentos de las redes neuronales convolucionales:

  • Las CNN utilizan campos receptivos locales y comparten parámetros para procesar imágenes de forma eficiente.
  • layer_conv_2d(filters, kernel_size, activation) extrae características espaciales.
  • layer_max_pooling_2d(pool_size) reduce la resolución y proporciona invariancia a la traslación.
  • layer_flatten() conecta la base convolucional con la cabeza del clasificador denso.
  • layer_dropout(rate) regulariza la cabeza de clasificación.
  • Las capas de aumento de datos (layer_random_flip(), etc.) reducen el sobreajuste.
  • El aprendizaje por transferencia con bases preentrenadas es el enfoque práctico para conjuntos de datos pequeños.
# Standard CNN architecture for image classification
model <- keras_model_sequential(input_shape = c(32, 32, 3)) |>
  layer_conv_2d(32,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(64,  c(3,3), activation = 'relu', padding = 'same') |>
  layer_max_pooling_2d(c(2,2)) |>
  layer_conv_2d(128, c(3,3), activation = 'relu', padding = 'same') |>
  layer_flatten() |>
  layer_dense(256, activation = 'relu') |>
  layer_dropout(0.5) |>
  layer_dense(num_classes, activation = 'softmax')

model |> compile('adam', 'categorical_crossentropy', 'accuracy')
summary(model)

Preguntas frecuentes

¿La lección «Fundamentos de las redes neuronales convolucionales» es gratis?

Sí — el texto completo de «Fundamentos de las redes neuronales convolucionales» 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 «Fundamentos de las redes neuronales convolucionales»?

Añada capas Conv2D y MaxPooling para tareas de clasificación de imágenes. 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 3 de 4.

¿Cuánto tiempo toma la lección «Fundamentos de las redes neuronales convolucionales»?

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

  1. Configuración de Keras y TensorFlow en R
  2. Construcción de modelos secuenciales
  3. Fundamentos de las redes neuronales convolucionales
  4. Entrenamiento, validación y prevención del sobreajuste
← Volver a R Academy