El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Introducción a las CNN

Siguiente ►
►

¿Qué es una Red Neuronal Convolucional (CNN)?

Una Red Neuronal Convolucional (CNN, por sus siglas en inglés) es un tipo de red neuronal profunda que se utiliza principalmente para tareas de procesamiento de imágenes y visión por computadora. Las CNN están diseñadas para reconocer patrones visuales directamente a partir de imágenes con una mínima preprocesamiento.

Características Clave de las CNN

  • Convoluciones: Operaciones matemáticas que permiten a la red extraer características locales de la imagen.
  • Pooling: Reducción de la dimensionalidad de las características extraídas, manteniendo la información más relevante.
  • Capas Profundas: Varias capas de convolución y pooling que permiten a la red aprender características de alto nivel.

Arquitectura Básica de una CNN

Una CNN típica consta de varias capas, cada una con una función específica. A continuación, se describe una arquitectura básica:

  1. Capa de Entrada: La imagen de entrada, generalmente representada como un tensor de dimensiones (altura, ancho, canales).
  2. Capas Convolucionales: Aplican filtros para extraer características locales.
  3. Capas de Pooling: Reducen la dimensionalidad de las características extraídas.
  4. Capas Completamente Conectadas: Conectan todas las neuronas de una capa a todas las neuronas de la siguiente capa.
  5. Capa de Salida: Produce la predicción final, como la clase de la imagen.

Ejemplo de Arquitectura CNN

Capa Tipo Dimensiones de Salida
Entrada Imagen 32x32x3
Convolución 32 filtros 3x3 32x32x32
Pooling Max Pooling 2x2 16x16x32
Convolución 64 filtros 3x3 16x16x64
Pooling Max Pooling 2x2 8x8x64
Completamente Conectada 128 neuronas 128
Salida Softmax Número de clases (e.g., 10)

Funcionamiento de las Capas Convolucionales

Las capas convolucionales son el componente central de las CNN. Utilizan filtros (o kernels) que se deslizan sobre la imagen de entrada para crear mapas de características.

Ejemplo de Convolución

Supongamos que tenemos una imagen de entrada de 5x5 y un filtro de 3x3:

Imagen de Entrada Filtro 3x3
1 2 3 0 1 1 0 -1
0 1 2 1 0 1 0 -1
1 2 3 0 1 1 0 -1
0 1 2 1 0
1 2 3 0 1

La convolución se realiza multiplicando cada elemento del filtro por el correspondiente en la imagen de entrada y sumando los resultados:

(1*1 + 2*0 + 3*(-1)) + (0*1 + 1*0 + 2*(-1)) + (1*1 + 2*0 + 3*(-1)) = -2

Este proceso se repite para cada posición del filtro sobre la imagen de entrada, generando un mapa de características.

Ejercicio Práctico

Ejercicio 1: Implementación Básica de una CNN en Python usando TensorFlow/Keras

import tensorflow as tf
from tensorflow.keras import layers, models

# Cargar y preprocesar los datos (usaremos CIFAR-10 como ejemplo)
(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0

# Definir la arquitectura de la CNN
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compilar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entrenar el modelo
model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))

Explicación del Código

  1. Carga y Preprocesamiento de Datos: Se carga el conjunto de datos CIFAR-10 y se normalizan las imágenes.
  2. Definición de la Arquitectura: Se define una CNN con tres capas convolucionales, seguidas de capas de pooling y capas completamente conectadas.
  3. Compilación del Modelo: Se especifica el optimizador, la función de pérdida y las métricas.
  4. Entrenamiento del Modelo: Se entrena el modelo con los datos de entrenamiento y se valida con los datos de prueba.

Ejercicio 2: Modificar la Arquitectura

Modifica la arquitectura de la CNN anterior para agregar una capa convolucional adicional y observa cómo afecta el rendimiento.

model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(128, (3, 3), activation='relu'),  # Capa adicional
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compilar y entrenar el modelo como antes
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))

Conclusión

En esta sección, hemos introducido las Redes Neuronales Convolucionales (CNN), explorando su arquitectura básica y su funcionamiento. Las CNN son poderosas herramientas para tareas de visión por computadora debido a su capacidad para aprender características jerárquicas de las imágenes. En los próximos temas, profundizaremos en las capas convolucionales y de pooling, así como en arquitecturas populares de CNN y sus aplicaciones en el reconocimiento de imágenes.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados