Escribir VGG desde cero en PyTorch

Continuando con mi serie sobre la construcción de redes neuronales convolucionales clásicas que revolucionaron el campo de la visión por computadora en los últimos 1-2 decenios, en la próxima parte construiremos VGG, una red neuronal convolucional muy profunda, desde cero utilizando PyTorch. Puede ver los artículos anteriores de la serie en mi perfil, principalmente LeNet5 y AlexNet.

Como antes, examinaremos la arquitectura y la intuión detrás de VGG y cómo los resultados eran en aquel entonces. Luego, exploraremos nuestro conjunto de datos, CIFAR100, y cargaremoslo en nuestro programa utilizando código eficiente en memoria. A continuación, implementaremos VGG16 (el número se refiere al número de capas, existen dos versiones básicas: VGG16 y VGG19) desde cero utilizando PyTorch y entrenaremosla con nuestro conjunto de datos, además de evaluarla en nuestro conjunto de prueba para ver cómo se comporta con datos no vistos

VGG

Sobre la base del trabajo de AlexNet, VGG se enfoca en otro aspecto crucial de las redes neuronales convolucionales (CNNs), la profundidad. Fue desarrollado por Simonyan y Zisserman. Normalmente consta de 16 capas convolucionales, pero también se puede ampliar a 19 capas (de ahí las dos versiones, VGG-16 y VGG-19). Todas las capas convolucionales consisten en filtros de 3×3. Puede leer más sobre la red en el artículo oficial aquí

arquitectura VGG16. Fuente

Carga de Datos

Conjunto de Datos

Antes de construir el modelo, una de las cosas más importantes en cualquier proyecto de Aprendizaje Automático es cargar, analizar y preprocesar el conjunto de datos. En este artículo, utilizaremos el conjunto de datos CIFAR-100. Este conjunto de datos es muy similar al CIFAR-10, excepto que tiene 100 clases con 600 imágenes cada una. Hay 500 imágenes de entrenamiento y 100 imágenes de prueba por clase. Las 100 clases en el CIFAR-100 están agrupadas en 20 superclases. Cada imagen viene con una etiqueta “fina” (la clase a la que pertenece) y una etiqueta “cruzada” (la superclase a la que pertenece). Aquí usaremos la etiqueta “fina”. Aquí está la lista de clases en el CIFAR-100:

Lista de Clases para el Conjunto de Datos CIFAR-100

Importando las bibliotecas

Principalmente trabajaremos con torch (utilizado para construir el modelo y entrenar), torchvision (para cargar/procesar datos, contiene conjuntos de datos y métodos para procesar estos conjuntos de datos en computación visual) y numpy (para manipulación matemática). También definiremos una variable device para que el programa pueda utilizar la GPU si está disponible.

import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from torch.utils.data.sampler import SubsetRandomSampler


# Configuración del dispositivo
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

Cargando los Datos

torchvision es una biblioteca que proporciona fácil acceso a toneladas de conjuntos de datos de visión computacional y métodos para preprocesar estos conjuntos de datos de manera fácil e intuitiva

• Definimos una función data_loader que devuelve datos de entrenamiento/validación o de prueba dependiendo de los argumentos
• Empezamos definiendo la variable normalize con las media y desviaciones típicas de cada uno de los canales (rojo, verde y azul) en el conjunto de datos. Estos pueden calcularse manualmente, pero también están disponibles en línea. Esto se utiliza en la variable transform donde reembolsamos los datos, los convertimos en tensores y luego los normalizamos
• Si el argumento test es verdadero, simplemente cargamos la partición de prueba del conjunto de datos y lo devolvemos usando cargadores de datos (explicado a continuación)
• En caso de que test sea falso (comportamiento predeterminado también), cargamos la partición de entrenamiento del conjunto de datos y lo dividimos aleatoriamente en entrenamiento y validación (0.9:0.1)
• Finalmente, hacemos uso de los cargadores de datos. Esto puede no afectar el rendimiento en el caso de un pequeño conjunto de datos como CIFAR100, pero realmente puede impedir el rendimiento en caso de grandes conjuntos de datos y generalmente se considera una buena práctica. Los cargadores de datos nos permiten iterar sobre los datos en lotes, y los datos se cargaron mientras iteraba y no todo a la vez en el inicio de su RAM

def data_loader(data_dir,
                batch_size,
                random_seed=42,
                valid_size=0.1,
                shuffle=True,
                test=False):
  
    normalize = transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2023, 0.1994, 0.2010],
    )

    # define transformaciones
    transform = transforms.Compose([
            transforms.Resize((227,227)),
            transforms.ToTensor(),
            normalize,
    ])

    if test:
        dataset = datasets.CIFAR100(
          root=data_dir, train=False,
          download=True, transform=transform,
        )

        data_loader = torch.utils.data.DataLoader(
            dataset, batch_size=batch_size, shuffle=shuffle
        )

        return data_loader

    # cargar el conjunto de datos
    train_dataset = datasets.CIFAR100(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    valid_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    num_train = len(train_dataset)
    indices = list(range(num_train))
    split = int(np.floor(valid_size * num_train))

    if shuffle:
        np.random.seed(random_seed)
        np.random.shuffle(indices)

    train_idx, valid_idx = indices[split:], indices[:split]
    train_sampler = SubsetRandomSampler(train_idx)
    valid_sampler = SubsetRandomSampler(valid_idx)

    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=batch_size, sampler=train_sampler)
 
    valid_loader = torch.utils.data.DataLoader(
        valid_dataset, batch_size=batch_size, sampler=valid_sampler)

    return (train_loader, valid_loader)


# conjunto de datos CIFAR100
train_loader, valid_loader = data_loader(data_dir='./data',
                                         batch_size=64)

test_loader = data_loader(data_dir='./data',
                              batch_size=64,
                              test=True)

VGG16 desde cero

Para construir el modelo desde cero, primero necesitamos entender cómo funcionan las definiciones de modelos en torch y los diferentes tipos de capas que utilizaremos aquí:

• Cada modelo personalizado debe heredar de la clase nn.Module ya que proporciona algunas funciones básicas que ayudan al modelo a entrenarse.
• En segundo lugar, hay dos cosas principales que debemos hacer. Primero, definir las diferentes capas de nuestro modelo dentro de la función __init__ y la secuencia en la que estas capas serán ejecutadas en el input dentro de la función forward

Vamos a definir ahora los diferentes tipos de capas que estamos utilizando aquí:

• nn.Conv2d: Estas son las capas convolucionales que aceptan el número de canales de entrada y salida como argumentos, junto con el tamaño del kernel para el filtro. También acepta cualquier strides o relleno si quieres aplicar esos
• nn.BatchNorm2d: Esto aplica la normalización por lotes al output de la capa convolucional
• nn.ReLU: Esta es la activación aplicada a varios outputs en la red.
• nn.MaxPool2d : Esto aplica max pooling a la salida con el tamaño del kernel dado
• nn.Dropout: Esto se utiliza para aplicar dropout a la salida con una probabilidad dada
• nn.Linear: Esto es básicamente una capa completamente conectada
• nn.Sequential: Esto técnicamente no es un tipo de capa, pero ayuda en la combinación de diferentes operaciones que forman parte del mismo paso

Usando este conocimiento, ahora podemos construir nuestro modelo VGG16 utilizando la arquitectura descrita en el documento:

class VGG16(nn.Module):
    def __init__(self, num_classes=10):
        super(VGG16, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU())
        self.layer2 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(), 
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU())
        self.layer4 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer5 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU())
        self.layer6 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU())
        self.layer7 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer8 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer9 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer10 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.layer11 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer12 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU())
        self.layer13 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2, stride = 2))
        self.fc = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(7*7*512, 4096),
            nn.ReLU())
        self.fc1 = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU())
        self.fc2= nn.Sequential(
            nn.Linear(4096, num_classes))
        
    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = self.layer5(out)
        out = self.layer6(out)
        out = self.layer7(out)
        out = self.layer8(out)
        out = self.layer9(out)
        out = self.layer10(out)
        out = self.layer11(out)
        out = self.layer12(out)
        out = self.layer13(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        out = self.fc1(out)
        out = self.fc2(out)
        return out

VGG16 desde cero

Hipotecarios

Una de las partes importantes de cualquier proyecto de máquina o aprendizaje profundo es optimizar los hiperparámetros. Aquí, no experimentaremos con diferentes valores para esos, sino que tendremos que definirlos previo mente. Estos incluyen definir el número de épocas, el tamaño de lote, la tasa de aprendizaje, la función de pérdida junto con el optimizador

num_classes = 100
num_epochs = 20
batch_size = 16
learning_rate = 0.005

model = VGG16(num_classes).to(device)


# Pérdida y optimizador
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay = 0.005, momentum = 0.9)  


# Entrenar el modelo
total_step = len(train_loader)

Estableciendo los hiperparámetros

Entrenamiento

Ahora estamos listos para entrenar nuestro modelo. Primero veremos cómo entrenamos nuestro modelo en torch y luego examinaremos el código:

• Para cada época, recorremos las imágenes y las etiquetas dentro de nuestro train_loader y movemos esas imágenes y etiquetas a la GPU si está disponible. Esto sucede automáticamente
• Usamos nuestro modelo para predecir sobre las etiquetas (model(images)) y luego calculamos la pérdida entre las predicciones y las etiquetas verdaderas usando nuestra función de pérdida (criterion(outputs, labels))
• Luego usamos esa pérdida para propagar hacia atrás (loss.backward) y actualizar las pesos (optimizer.step()). Pero recuerda que debes establecer las gradientes en cero antes de cada actualización. Esto se hace usando optimizer.zero_grad()
• También, al final de cada época usamos nuestro conjunto de validación para calcular la precisión del modelo. En este caso, no necesitamos gradientes así que usamos with torch.no_grad() para una evaluación más rápida

Ahora, combinamos todo esto en el siguiente código:

total_step = len(train_loader)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        # Move tensors to the configured device
        images = images.to(device)
        labels = labels.to(device)
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))
            
    # Validation
    with torch.no_grad():
        correct = 0
        total = 0
        for images, labels in valid_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            del images, labels, outputs
    
        print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total)) 

Entrenamiento

Podemos ver la salida del código anterior como se muestra a continuación, que muestra que el modelo está aprendiendo realmente ya que la pérdida disminuye con cada época:

Pérdidas de entrenamiento

Pruebas

Para las pruebas, utilizamos exactamente el mismo código que para la validación, pero con el test_loader:

with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        del images, labels, outputs

    print('Accuracy of the network on the {} test images: {} %'.format(10000, 100 * correct / total))   

Pruebas

Usando el código anterior y entrenando el modelo durante 20 épocas, logramos alcanzar una precisión de 75% en el conjunto de prueba.

Conclusión

Ahora vamos a concluir lo que hemos hecho en este artículo:

• Empezamos entendiendo la arquitectura y los diferentes tipos de capas del modelo VGG-16
• A continuación, cargamos y preprocesamos el conjunto de datos CIFAR100 usando torchvision
• Luego, usamos PyTorch para construir nuestro modelo VGG-16 desde cero, junto con la comprensión de diferentes tipos de capas disponibles en torch
• Finalmente, entrenamos y probamos nuestro modelo en el conjunto de datos CIFAR100, y el modelo pareció funcionar bien en el conjunto de prueba con un 75% de precisión

Trabajo futuro

Con este artículo, obtienes una buena introducción y aprendizaje práctico, pero aprenderás mucho más si extendes esto y veas qué otras cosas puedes hacer:

• Puedes probar con diferentes conjuntos de datos. Uno de estos conjuntos es CIFAR10 o una subcolección del conjunto de datos ImageNet.
• Puedes experimentar con diferentes hiperparámetros y ver la mejor combinación de ellos para el modelo
• Finalmente, puedes intentar agregar o eliminar capas del conjunto de datos para ver su impacto en la capacidad del modelo. Aún mejor, intenta construir la versión VGG-19 de este modelo.