Redes convolucionales

Las redes neuronales convolucionales (CNNs, por sus siglas en inglés) son un tipo especializado de redes neuronales que se utilizan, sobre todo, en la clasificación de imágenes y otros tipos de datos con estructura espacial o temporal (como señales de audio o video). A diferencia de las redes neuronales tradicionales, las CNNs aprovechan las propiedades de la estructura de los datos para extraer características de forma jerárquica.

Estructura de las Redes Neuronales Convolucionales

Una CNN suele estar compuesta por tres tipos principales de capas:

1. Capa Convolucional (Conv2D): Realiza una operación de convolución sobre la imagen de entrada, aplicando un conjunto de filtros o “kernels”. Esto ayuda a detectar características locales, como bordes, texturas y patrones. La salida de esta capa es un conjunto de mapas de características (feature maps) que resaltan las características detectadas en la imagen.
2. Capa de Pooling (MaxPooling2D): Esta capa reduce la dimensionalidad de los mapas de características, disminuyendo el tamaño espacial de la representación. Esto ayuda a reducir la cantidad de parámetros, mejorar la eficiencia y evitar el sobreajuste. La operación más común es el max pooling, que toma el valor máximo en una región de la imagen.
3. Capas Completamente Conectadas (Fully Connected): Estas capas suelen estar al final de la red. Conectan cada neurona de una capa con todas las neuronas de la siguiente. Su función es procesar la salida de las capas anteriores para realizar una predicción final.

Ejemplo de Estructura de una CNN

Una red CNN para clasificación de imágenes podría tener la siguiente estructura básica:

• Capa de entrada: imagen de tamaño (32, 32, 3) (por ejemplo, una imagen en color de 32×32).
• Primera capa convolucional: 32 filtros de 3×3.
• Primera capa de pooling: max pooling con tamaño 2×2.
• Segunda capa convolucional: 64 filtros de 3×3.
• Segunda capa de pooling: max pooling de 2×2.
• Capas densamente conectadas (fully connected).
• Capa de salida: una neurona por cada clase de salida.

Implementación de una CNN en Python con Keras

Vamos a implementar una CNN básica utilizando Keras para clasificar imágenes del conjunto de datos CIFAR-10.

Paso 1: Preparar el entorno

Primero, asegúrate de tener las bibliotecas necesarias:

!pip install tensorflow

Paso 2: Implementación

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

# Cargar el dataset CIFAR-10
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0  # Normalizar

# Definir la estructura 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.MaxPooling2D((2, 2)),

    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10)
])

# Compilar el modelo
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

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

# Evaluar el modelo
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'\nTest accuracy: {test_acc}')

Explicación del Código

1. Modelo Secuencial: Creamos un modelo secuencial que contiene varias capas.
2. Capas Convolucionales: Añadimos tres capas convolucionales para extraer características a diferentes niveles.
3. MaxPooling2D: Después de cada convolución, reducimos las dimensiones con una capa de max pooling.
4. Capas Completamente Conectadas: Finalmente, aplanamos las características y las pasamos a una capa densamente conectada.
5. Compilación: Utilizamos el optimizador Adam, que es una variante del gradiente descendente, y la pérdida de entropía cruzada categórica, adecuada para clasificación.
6. Entrenamiento: Entrenamos el modelo con el conjunto de datos de entrenamiento y lo validamos en el conjunto de datos de prueba.

Visualización de Resultados

Podemos graficar la precisión y la pérdida para ver el rendimiento del modelo durante el entrenamiento.

# Gráfica de precisión
plt.plot(history.history['accuracy'], label='Precisión de entrenamiento')
plt.plot(history.history['val_accuracy'], label = 'Precisión de prueba')
plt.xlabel('Época')
plt.ylabel('Precisión')
plt.ylim([0, 1])
plt.legend(loc='lower right')
plt.show()

# Gráfica de pérdida
plt.plot(history.history['loss'], label='Pérdida de entrenamiento')
plt.plot(history.history['val_loss'], label='Pérdida de prueba')
plt.xlabel('Época')
plt.ylabel('Pérdida')
plt.legend(loc='upper right')
plt.show()

Interpretación de Resultados

• Si la precisión de entrenamiento es significativamente mayor que la de prueba, el modelo podría estar sobreajustado.
• Si ambas precisiones son bajas, podría ser necesario ajustar el modelo aumentando la cantidad de datos o cambiando la estructura de la red.

Conclusión

Las CNNs son potentes para tareas de clasificación de imágenes debido a su capacidad para capturar características espaciales y jerárquicas. Este ejemplo te brinda una base para implementar y entrenar una CNN, pudiendo personalizar el número de capas, filtros y otros parámetros según el problema a resolver.