El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, exploraremos dos componentes fundamentales de las Redes Neuronales Convolucionales (CNN): las capas convolucionales y las capas de pooling. Estas capas son esenciales para el procesamiento y la extracción de características en tareas de visión por computadora.

Capas Convolucionales

1.1. ¿Qué es una capa convolucional?

Una capa convolucional aplica un filtro (o kernel) a una entrada (como una imagen) para producir una salida (o mapa de características). Este proceso se conoce como convolución. La convolución permite a la red extraer características locales de la entrada, como bordes, texturas y patrones.

1.2. Parámetros de la capa convolucional

Filtros (Kernels): Son matrices pequeñas que se deslizan sobre la entrada para realizar la convolución. Cada filtro detecta una característica específica.
Stride: Es el paso con el que el filtro se desliza sobre la entrada. Un stride mayor reduce el tamaño del mapa de características.
Padding: Es la adición de ceros alrededor de la entrada para controlar el tamaño del mapa de características. Puede ser 'valid' (sin padding) o 'same' (con padding para mantener el tamaño).

1.3. Ejemplo de convolución

Supongamos que tenemos una imagen de entrada de 5x5 y un filtro de 3x3 con stride 1 y sin padding.

import numpy as np

# Imagen de entrada
input_image = np.array([
    [1, 2, 3, 0, 1],
    [4, 5, 6, 1, 2],
    [7, 8, 9, 2, 3],
    [0, 1, 2, 3, 4],
    [1, 2, 3, 4, 5]
])

# Filtro (kernel)
filter = np.array([
    [1, 0, -1],
    [1, 0, -1],
    [1, 0, -1]
])

# Realizar la convolución
output = np.zeros((3, 3))
for i in range(3):
    for j in range(3):
        output[i, j] = np.sum(input_image[i:i+3, j:j+3] * filter)

print(output)

1.4. Resultado de la convolución

La salida de la convolución es un mapa de características de 3x3:

[[  2.  -1.  -4.]
 [ 11.   2.  -7.]
 [ 20.   5. -10.]]

Capas de Pooling

2.1. ¿Qué es una capa de pooling?

Una capa de pooling reduce las dimensiones del mapa de características, resumiendo las características en regiones no superpuestas. Esto ayuda a reducir la cantidad de parámetros y el costo computacional, y también controla el sobreajuste.

2.2. Tipos de pooling

Max Pooling: Toma el valor máximo en cada región.
Average Pooling: Toma el valor promedio en cada región.

2.3. Ejemplo de max pooling

Supongamos que tenemos un mapa de características de 4x4 y aplicamos max pooling con un tamaño de ventana de 2x2 y stride 2.

# Mapa de características
feature_map = np.array([
    [1, 3, 2, 4],
    [5, 6, 1, 2],
    [7, 8, 3, 0],
    [2, 1, 4, 5]
])

# Realizar max pooling
pooled_output = np.zeros((2, 2))
for i in range(2):
    for j in range(2):
        pooled_output[i, j] = np.max(feature_map[i*2:i*2+2, j*2:j*2+2])

print(pooled_output)

2.4. Resultado de max pooling

La salida del max pooling es un mapa de características de 2x2:

[[6. 4.]
 [8. 5.]]

Ejercicio Práctico

Ejercicio

Dada la siguiente imagen de entrada y filtro, realiza la convolución y luego aplica max pooling:

Imagen de entrada (6x6):

[[1, 2, 3, 0, 1, 2],
 [4, 5, 6, 1, 2, 3],
 [7, 8, 9, 2, 3, 4],
 [0, 1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5, 6],
 [2, 3, 4, 5, 6, 7]]

Filtro (3x3):

[[1, 0, -1],
 [1, 0, -1],
 [1, 0, -1]]

Max pooling con tamaño de ventana 2x2 y stride 2.

Solución

# Imagen de entrada
input_image = np.array([
    [1, 2, 3, 0, 1, 2],
    [4, 5, 6, 1, 2, 3],
    [7, 8, 9, 2, 3, 4],
    [0, 1, 2, 3, 4, 5],
    [1, 2, 3, 4, 5, 6],
    [2, 3, 4, 5, 6, 7]
])

# Filtro (kernel)
filter = np.array([
    [1, 0, -1],
    [1, 0, -1],
    [1, 0, -1]
])

# Realizar la convolución
conv_output = np.zeros((4, 4))
for i in range(4):
    for j in range(4):
        conv_output[i, j] = np.sum(input_image[i:i+3, j:j+3] * filter)

print("Convolución:")
print(conv_output)

# Realizar max pooling
pooled_output = np.zeros((2, 2))
for i in range(2):
    for j in range(2):
        pooled_output[i, j] = np.max(conv_output[i*2:i*2+2, j*2:j*2+2])

print("Max Pooling:")
print(pooled_output)

Resultado

La salida de la convolución es:

[[  2.  -1.  -4.  -7.]
 [ 11.   2.  -7. -10.]
 [ 20.   5. -10. -15.]
 [ 29.   8. -13. -18.]]

La salida del max pooling es:

[[11. -1.]
 [29.  8.]]

Conclusión

En esta sección, hemos aprendido sobre las capas convolucionales y de pooling, dos componentes esenciales de las Redes Neuronales Convolucionales. Las capas convolucionales permiten la extracción de características locales, mientras que las capas de pooling reducen la dimensionalidad y ayudan a controlar el sobreajuste. Con estos conceptos, estamos mejor preparados para entender y construir modelos de CNN más complejos. En el próximo tema, exploraremos arquitecturas populares de CNN y sus aplicaciones en el reconocimiento de imágenes.

Capas Convolucionales y de Pooling