Construyendo una Red Neuronal Convolucional con PyTorch

Construyendo una CNN con PyTorch

 

Introducción

 

Una Red Neuronal Convolucional (CNN o ConvNet) es un algoritmo de aprendizaje profundo diseñado específicamente para tareas donde el reconocimiento de objetos es crucial, como la clasificación, detección y segmentación de imágenes. Las CNN pueden lograr una precisión de vanguardia en tareas de visión complejas, impulsando muchas aplicaciones en la vida real como sistemas de vigilancia, gestión de almacenes y más.

• Los mejores 5 cursos de Power BI (2024)
• Esta investigación de IA propone LayoutNUWA un modelo de IA que trata la generación de diseño como una tarea de generación de código para mejorar la información semántica y aprovechar la experiencia oculta de diseño de los modelos de lenguaje grandes (LLMs).
• Diagnóstico de la enfermedad de Parkinson utilizando análisis de datos de muestras de voz selección de características

Como humanos, podemos reconocer fácilmente objetos en imágenes al analizar patrones, formas y colores. Las CNN también pueden entrenarse para realizar este reconocimiento, aprendiendo qué patrones son importantes para la diferenciación. Por ejemplo, al tratar de distinguir entre una foto de un gato y un perro, nuestro cerebro se enfoca en la forma única, texturas y rasgos faciales. Una CNN aprende a detectar estos mismos tipos de características distintivas. Incluso para tareas de categorización muy detalladas, las CNN pueden aprender representaciones de características complejas directamente desde los píxeles.

En esta publicación de blog, aprenderemos sobre las Redes Neuronales Convolucionales y cómo usarlas para construir un clasificador de imágenes con PyTorch.

 

¿Cómo funcionan las Redes Neuronales Convolucionales?

 

Las redes neuronales convolucionales (CNN) se utilizan comúnmente para tareas de clasificación de imágenes. A alto nivel, las CNN contienen tres tipos principales de capas:

1. Capas convolucionales. Aplican filtros convolucionales a la entrada para extraer características. Las neuronas en estas capas se llaman filtros y capturan patrones espaciales en la entrada.
2. Capas de agrupación. Reducen la resolución de los mapas de características de las capas convolucionales para consolidar información. Las estrategias más comunes son el agrupamiento máximo y el agrupamiento promedio.
3. Capas totalmente conectadas. Toman las características de alto nivel de las capas convolucionales y de agrupación como entrada para la clasificación. Se pueden apilar múltiples capas totalmente conectadas.

Los filtros convolucionales actúan como detectores de características, aprendiendo a activarse cuando ven tipos específicos de patrones o formas en la imagen de entrada. A medida que se aplican estos filtros en toda la imagen, producen mapas de características que resaltan dónde están presentes ciertas características.

Por ejemplo, un filtro puede activarse al ver líneas verticales, produciendo un mapa de características que muestra las líneas verticales en la imagen. Múltiples filtros aplicados a la misma entrada producen una pila de mapas de características, capturando diferentes aspectos de la imagen.

   

Apilando múltiples capas convolucionales, una CNN puede aprender jerarquías de características, construyendo desde bordes y patrones simples hasta formas y objetos más complejos. Las capas de agrupación ayudan a consolidar las representaciones de características y proporcionan invarianza a la traslación.

Las capas totalmente conectadas finales toman estas representaciones de características aprendidas y las utilizan para la clasificación. Para una tarea de clasificación de imágenes, la capa de salida generalmente utiliza una activación softmax para producir una distribución de probabilidad sobre las clases.

En PyTorch, podemos definir las capas convolucionales, de agrupación y totalmente conectadas para construir una arquitectura de CNN. Aquí hay un código de ejemplo:

# Capas convolucionales
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)
self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size)

# Capa de agrupación
self.pool = nn.MaxPool2d(kernel_size)

# Capas totalmente conectadas
self.fc1 = nn.Linear(in_features, out_features)
self.fc2 = nn.Linear(in_features, out_features)

 

Luego podemos entrenar la CNN en datos de imágenes, utilizando retropropagación y optimización. Las capas convolucionales y de agrupación aprenderán automáticamente representaciones de características efectivas, permitiendo que la red logre un rendimiento sólido en tareas de visión.

 

Comenzando con las CNN

 

En esta sección, cargaremos CIFAR10 y construiremos y entrenaremos un modelo de clasificación basado en CNN utilizando PyTorch. El conjunto de datos CIFAR10 proporciona imágenes RGB de 32×32 píxeles en diez clases, lo cual es útil para probar modelos de clasificación de imágenes. Hay diez clases etiquetadas con enteros del 0 al 9.

Nota: El código de ejemplo es una versión modificada del blog MachineLearningMastery.com.

Primero, usaremos torchvision para descargar y cargar el conjunto de datos CIFAR10. También usaremos torchvision para transformar tanto los conjuntos de prueba como los de entrenamiento en tensores.

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

transform = torchvision.transforms.Compose(
    [torchvision.transforms.ToTensor()]
)

train = torchvision.datasets.CIFAR10(
    root="data", train=True, download=True, transform=transform
)

test = torchvision.datasets.CIFAR10(
    root="data", train=False, download=True, transform=transform
)

 

Descargando https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz a data/cifar-10-python.tar.gz

100%|██████████| 170498071/170498071 [00:10<00:00, 15853600.54it/s]

Extrayendo data/cifar-10-python.tar.gz a data
Los archivos ya han sido descargados y verificados

 

Después de eso, utilizaremos un data loader y dividiremos las imágenes en lotes. 

tamaño_lote = 32
trainloader = torch.utils.data.DataLoader(
    train, batch_size=tamaño_lote, shuffle=True
)
testloader = torch.utils.data.DataLoader(
    test, batch_size=tamaño_lote, shuffle=True
)

 

Para visualizar la imagen en un solo lote de imágenes, utilizaremos matplotlib y la función de utilidad de torchvision. 

from torchvision.utils import make_grid
import matplotlib.pyplot as plt

def mostrar_lote(dl):
    for imágenes, etiquetas in dl:
        fig, ax = plt.subplots(figsize=(12, 12))
        ax.set_xticks([]); ax.set_yticks([])
        ax.imshow(make_grid(imágenes[:64], nrow=8).permute(1, 2, 0))
        break
mostrar_lote(trainloader)

 

Como podemos ver, tenemos imágenes de autos, animales, aviones y barcos. 

   

A continuación, construiremos nuestro modelo CNN. Para ello, debemos crear una clase en Python e inicializar las capas de convolución, maxpool y fully connected. Nuestra arquitectura tiene 2 capas de convolución con pooling y capas lineales. 

Después de inicializar, no conectaremos todas las capas secuencialmente en la función forward. Si eres nuevo en PyTorch, debes leer Interpretable Neural Networks with PyTorch para entender cada componente en detalle. 

class ModeloCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=(3,3), stride=1, padding=1)
        self.act1 = nn.ReLU()
        self.drop1 = nn.Dropout(0.3)
 
        self.conv2 = nn.Conv2d(32, 32, kernel_size=(3,3), stride=1, padding=1)
        self.act2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=(2, 2))
 
        self.flat = nn.Flatten()
 
        self.fc3 = nn.Linear(8192, 512)
        self.act3 = nn.ReLU()
        self.drop3 = nn.Dropout(0.5)
 
        self.fc4 = nn.Linear(512, 10)
 
    def forward(self, x):
        # entrada 3x32x32, salida 32x32x32
        x = self.act1(self.conv1(x))
        x = self.drop1(x)
        # entrada 32x32x32, salida 32x32x32
        x = self.act2(self.conv2(x))
        # entrada 32x32x32, salida 32x16x16
        x = self.pool2(x)
        # entrada 32x16x16, salida 8192
        x = self.flat(x)
        # entrada 8192, salida 512
        x = self.act3(self.fc3(x))
        x = self.drop3(x)
        # entrada 512, salida 10
        x = self.fc4(x)
        return x

 

Ahora inicializaremos nuestro modelo, estableceremos la función de pérdida y el optimizador. 

modelo = ModeloCNN()
función_de_pérdida = nn.CrossEntropyLoss()
optimizador = optim.SGD(modelo.parameters(), lr=0.001, momentum=0.9)

 

En la fase de entrenamiento, entrenaremos nuestro modelo durante 10 épocas.

1. Estamos utilizando la función forward del modelo para un pase hacia adelante, luego un pase hacia atrás utilizando la función de pérdida y finalmente actualizando los pesos. Este paso es casi similar en todo tipo de modelos de redes neuronales.
2. Después de eso, estamos utilizando un cargador de datos de prueba para evaluar el rendimiento del modelo al final de cada época.
3. Calculando la precisión del modelo e imprimiendo los resultados.

n_epochs = 10
for epoch in range(n_epochs):
    for i, (images, labels) in enumerate(trainloader):
        # Pase hacia adelante
        outputs = model(images)
        loss = loss_fn(outputs, labels)

        # Pase hacia atrás y optimizar
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in testloader:
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print('Época %d: Precisión: %d %%' % (epoch,(100 * correct / total)))

Nuestro modelo simple ha logrado una precisión del 57%, que es baja. Pero puedes mejorar el rendimiento del modelo agregando más capas, ejecutándolo durante más épocas y optimización de hiperparámetros.

Época 0: Precisión: 41 %
Época 1: Precisión: 46 %
Época 2: Precisión: 48 %
Época 3: Precisión: 50 %
Época 4: Precisión: 52 %
Época 5: Precisión: 53 %
Época 6: Precisión: 53 %
Época 7: Precisión: 56 %
Época 8: Precisión: 56 %
Época 9: Precisión: 57 %

Con PyTorch, no tienes que crear todos los componentes de las redes neuronales convolucionales desde cero, ya que ya están disponibles. Se vuelve aún más sencillo si utilizas `torch.nn.Sequential`. PyTorch está diseñado para ser modular y ofrece una mayor flexibilidad en la construcción, entrenamiento y evaluación de redes neuronales.

Conclusión

En esta publicación, exploramos cómo construir y entrenar una red neuronal convolucional para la clasificación de imágenes utilizando PyTorch. Cubrimos los componentes principales de las arquitecturas de CNN: capas convolucionales para la extracción de características, capas de pooling para el muestreo y capas completamente conectadas para la predicción.

Espero que esta publicación haya proporcionado una visión general útil de la implementación de redes neuronales convolucionales con PyTorch. Las CNN son arquitecturas fundamentales en el aprendizaje profundo para la visión por computadora, y PyTorch nos brinda la flexibilidad de construir, entrenar y evaluar rápidamente estos modelos.

Abid Ali Awan (@1abidaliawan) es un profesional certificado en ciencia de datos a quien le encanta construir modelos de aprendizaje automático. Actualmente, se centra en la creación de contenido y la escritura de blogs técnicos sobre tecnologías de aprendizaje automático y ciencia de datos. Abid tiene una maestría en Gestión de Tecnología y una licenciatura en Ingeniería de Telecomunicaciones. Su visión es construir un producto de IA utilizando una red neuronal gráfica para estudiantes que luchan contra enfermedades mentales.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!