¿Qué son las Redes Neuronales Convolucionales (CNNs)?

Las Redes Neuronales Convolucionales (CNNs) son un tipo de red neuronal especialmente eficaz para tareas de procesamiento de datos con una estructura de cuadrícula, como las imágenes. Las CNNs han demostrado ser extremadamente exitosas en el reconocimiento de imágenes, la detección de objetos y otras tareas de visión por computadora.

Conceptos Clave

Convolución: Es una operación matemática que combina dos conjuntos de información. En el contexto de las CNNs, se utiliza para extraer características de las imágenes.
Filtros/Kernels: Son matrices pequeñas que se deslizan sobre la imagen de entrada para realizar la operación de convolución.
Mapas de Características: Son el resultado de aplicar un filtro a la imagen de entrada.
Pooling: Es una técnica de reducción de dimensionalidad que reduce la cantidad de parámetros y el costo computacional.
Capas Convolucionales: Son las capas donde se aplican los filtros para extraer características.
Capas de Pooling: Son las capas donde se aplica la operación de pooling.
Capas Completamente Conectadas: Son las capas finales de la red donde cada neurona está conectada a todas las neuronas de la capa anterior.

Arquitectura Básica de una CNN

Una CNN típica está compuesta por una secuencia de capas convolucionales y de pooling, seguidas por una o más capas completamente conectadas. La estructura básica es la siguiente:

Entrada: Imagen de entrada.
Capas Convolucionales: Aplicación de filtros para extraer características.
Capas de Pooling: Reducción de dimensionalidad.
Capas Completamente Conectadas: Clasificación final.

Ejemplo Práctico: Construcción de una CNN Simple

Vamos a construir una CNN simple utilizando PyTorch. Esta red será capaz de clasificar imágenes del conjunto de datos CIFAR-10.

Paso 1: Importar las Bibliotecas Necesarias

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

Paso 2: Preparar el Conjunto de Datos

# Transformaciones para normalizar los datos
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

# Descargar y cargar el conjunto de datos CIFAR-10
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Paso 3: Definir la Arquitectura de la CNN

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

Paso 4: Definir la Función de Pérdida y el Optimizador

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Paso 5: Entrenar la Red

for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # obtener las entradas; data es una lista de [inputs, labels]
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # imprimir estadísticas
        running_loss += loss.item()
        if i % 2000 == 1999:    # imprimir cada 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

Paso 6: Evaluar la Red

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

Ejercicio Práctico

Ejercicio 1: Modificar la Arquitectura de la CNN

Modifica la arquitectura de la CNN para agregar una tercera capa convolucional. Asegúrate de ajustar las dimensiones de las capas completamente conectadas en consecuencia.

Solución

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.conv3 = nn.Conv2d(16, 32, 5)
        self.fc1 = nn.Linear(32 * 2 * 2, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 32 * 2 * 2)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

Conclusión

En esta sección, hemos introducido las Redes Neuronales Convolucionales (CNNs) y su arquitectura básica. También hemos construido una CNN simple utilizando PyTorch y hemos visto cómo entrenarla y evaluarla. En el próximo módulo, profundizaremos en la construcción de una CNN desde cero y exploraremos técnicas avanzadas como el aprendizaje por transferencia y el ajuste fino de modelos preentrenados.

Introducción a las CNNs

¿Qué son las Redes Neuronales Convolucionales (CNNs)?

Conceptos Clave

Arquitectura Básica de una CNN

Ejemplo Práctico: Construcción de una CNN Simple

Paso 1: Importar las Bibliotecas Necesarias

Paso 2: Preparar el Conjunto de Datos

Paso 3: Definir la Arquitectura de la CNN

Paso 4: Definir la Función de Pérdida y el Optimizador

Paso 5: Entrenar la Red

Paso 6: Evaluar la Red

Ejercicio Práctico

Ejercicio 1: Modificar la Arquitectura de la CNN

Solución

Conclusión

PyTorch: De Principiante a Avanzado

Módulo 1: Introducción a PyTorch

Módulo 2: Construcción de Redes Neuronales

Módulo 3: Entrenamiento de Redes Neuronales

Módulo 4: Redes Neuronales Convolucionales (CNNs)

Módulo 5: Redes Neuronales Recurrentes (RNNs)

Módulo 6: Temas Avanzados

Módulo 7: Estudios de Caso y Proyectos