Writing VGG from Scratch in PyTorch

Продолжая мою серию статей о создании классических конｖｏｌｕｔｉｏｎａｌных нейронных сетей, которые революционизировали сферу компьютерного зрения за последние 1-2 десятилетия, в следующей части мы создадим VGG, очень глубокую конｖｏｌｕｔｉｏｎａльную нейронную сеть, с нуля, используя PyTorch. Вы можете увидеть предыдущие статьи в этой серии на моем профиле, в основном LeNet5 и AlexNet.

Как и ранее, мы рассмотрим архитектуру и интуициюза VGG и результаты, которые были в то время. Затем мы исследуем нашу выборку данных CIFAR100 и загрузим ее в нашу программу с использованием эффективного кода по счету памяти. Затем мы реализуем VGG16 (число указывает на количество слоев, существуют две версии, VGG16 и VGG19) с нуля, используя PyTorch, и обучим его на нашей выборке данных, а также оценим его на нашем тестовом наборе, чтобы увидеть, как он работает с невиданными данными

VGG

Возводясь на основе работы AlexNet, VGG сфокусируется на еще одной важной аспекте конволюционных нейронных сетей (CNN), глубины. Она была разработана Simonyan и Zisserman. Она обычно состоит из 16 конволюционных слоев, но может быть расширена до 19 слоев (таким образом, есть две версии: VGG-16 и VGG-19). Все конволюционные слои состоят из фильтров 3×3. Более подробную информацию о сети вы можете прочитать в официальной статье здесь

архитектуры VGG16. Источник

Загрузка данных

Набор данных

Перед созданием модели одним из самых важных действий в любом проекте машинного обучения является загрузка, анализ и предварительная обработка набора данных. В этой статье мы будем использовать набор данных CIFAR-100. Этот набор данных похож на CIFAR-10, за исключением того, что он содержит 100 классов, каждый из которых содержит 600 изображений. Всего есть 500 тренировочных изображений и 100 тестовых изображений в каждом классе. 100 классов в CIFAR-100 разделены на 20 суперклассов. Каждое изображение сопровождается “тонкой” меткой (классом, к которому оно относится) и “толстой” меткой (суперклассом, к которому оно относится). Мы будем использовать “тонкую” метку здесь. Вот список классов в CIFAR-100:

Список классов для набора данных CIFAR-100

Импортирование библиотек

Мы будем работать главным образом с torch (используется для создания модели и обучения), torchvision (для загрузки/обработки данных, содержит наборы данных и методы для обработки этих наборов данных в компьютерном зрении) и numpy (для математической манипуляции). Мы также будем определять переменную device, чтобы программа могла использовать GPU, если он доступен

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')

Загрузка данных

torchvision — это библиотека, предоставляющая легкий доступ к большому количеству компьютерно-визуальных датасетов и методов их предварительной обработки в простом и интуитивно понятном для использования способе

• Мы определяем функцию data_loader, которая возвращает данные тренировки/валидации или тестовые данные в зависимости от аргументов
• Начинаем с определения переменной normalize с средними значениями и стандартными отклонениями каждого канала (красного, зеленого и синего) в датасете. Эти значения можно вычислить вручную, но они также доступны в Интернете. Это используется в переменной transform, где мы увеличиваем размер данных, конвертируем их в тензоры и затем нормализуем
• Если аргумент test равен True, мы просто загружаем тестовую часть датасета и возвращаем ее с помощью загрузчиков данных (подробнее см. ниже)
• В случае, если test false (разметки по умолчанию), мы загружаем часть тренировки датасета и рандомизируем ее в тренировочную и валидационную выборку (90:10)
• В конце применяем загрузчики данных. Это может не оказаться влиянием на performance при использовании маленьких данных, как CIFAR100, но它可以 серьезно ограничить performance при работе с крупными данными и обычно считается хорошей практикой. Загрузчики данных позволяют нам итерационно проходить по данным в batch’ах, и данные загружаются во время итерации, а не все в начале загрузки в вашем 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],
    )

    # определение трансформаций
    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

    # загрузка набора данных
    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)


# набор данных 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 с нуля

Для создания модели с нуля, нам надо сначала понять, как работают определения моделей в torch и различные типы слоев, которые мы будем использовать здесь:

• Каждая пользовательская модель должна наследоваться от класса nn.Module, так как он обеспечивает основные функции, которые помогают модели обучаться.
• Второе, есть две основные вещи, которые нам нужно сделать. Первое, определить различные слои нашей модели внутри функции __init__ и последовательность, в которой这些层次将被执行在输入上 inside the forward function

Теперь let’s define the various types of layers that we are using here:

• nn.Conv2d: These are the convolutional layers that accepts the number of input and output channels as arguments, along with kernel size for the filter. It also accepts any strides or padding if you want to apply those
• nn.BatchNorm2d: This applies batch normalization to the output from the convolutional layer
• nn.ReLU: This is the activation applied to various outputs in the network.
• nn.MaxPool2d : Это применяет максимальное пулинг к выходу с указанным размером ядра
• nn.Dropout: Используется для применения дропаута к выходу с заданной вероятностью
• nn.Linear: Это, по сути, полностью связанный слой
• nn.Sequential: Технически это не тип слоя, но помогает объединять различные операции, являющиеся частью одного шага

Используя эту информацию, мы теперь можем построить нашу модель VGG16 с использованием архитектуры из статьи:

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 с нуля

Гиперпараметры

Одна из важных частей любого проекта по машинному или глубокому обучению – это оптимизация гиперпараметров. Здесь мы не будем экспериментировать с различными значениями, но мы должны определить их заранее. К ним относятся количество эпох, размер батча, скорость обучения, функция потерь вместе с оптимизатором

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

model = VGG16(num_classes).to(device)


# Функция потерь и оптимизатор
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay = 0.005, momentum = 0.9)  


# Обучение модели
total_step = len(train_loader)

Установка гиперпараметров

Обучение

Мы сейчас готовы начать тренировать нашу модель. Мы сначала посмотрим, как тренировать нашу модель в torch, а затем посмотрим на код:

• Для каждой эпохи мы проходим через изображения и метки в нашем train_loader и, если доступно, перемещаем эти изображения и метки на GPU. Это происходит автоматически
• Мы используем нашу модель, чтобы предсказать метки (model(images)), а затем вычисляем потерю между предсказаниями и истинными метками с помощью нашей функции потерь (criterion(outputs, labels))
• После этого мы используем эту потерю для обратной пропагирации (loss.backward) и обновляем веса (optimizer.step()). Но помнитете установить градиенты в нуль перед каждым обновлением. Это делается с помощью optimizer.zero_grad()
• Также в конце каждой эпохи мы используем нашу валидационную выборку, чтобы вычислить точность модели. В этом случае мы не нужны градиенты, поэтому мы используем with torch.no_grad() для быстрой оценки

Теперь мы объединяем все это в следующий код:

total_step = len(train_loader)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        # Перемещаем тензоры на настроенное устройство
        images = images.to(device)
        labels = labels.to(device)
        
        # Фронт-проход
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Задняя пропагирация и оптимизация
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))
            
    # Валидация
    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)) 

Тренировка

Мы можем увидеть выход данного кода, как показано ниже, который действительно показывает, что модель учится, поскольку потеря уменьшается с каждой эпохой:

Потери тренировки

Тестирование

Для тестирования мы используем совершенно тот же код, что и для валидации, но с 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))   

Тестирование

Используя указанный выше код и обучая модель на 20 эпохах, мы смогли достичь точности 75% на тестовом наборе данных.

Заключение

Теперь let’s summarize what we did in this article:

• Начали мы с понимания архитектуры и различных типов слоев в модели VGG-16
• Далее мы загрузили и предпроцессорировали набор данных CIFAR100 с использованием torchvision
• Потом мы использовали PyTorch, чтобы построить нашу модель VGG-16 с нуля, а также понять различные типы слоев, доступных в torch
• В конце концов, мы обучили и тестировали нашу модель на наборе данных CIFAR100, и модель казалась работать хорошо на тестовом наборе данных с 75% точностью

Будущая работа

Utilizing this article, you get a good introduction and hands-on learning, but you’ll learn much more if you extend this and see what else you can do:

• Вы можете essay using различные наборы данных. Один из таких наборов данных – CIFAR10 или небольшой под набора данных ImageNet.
• Вы можете экспериментировать с различными гиперпараметрами и увидеть лучшую комбинацию их для модели
• В конечном итоге, вы можете essay добавляя или удаляя слои из набора данных, чтобы увидеть их влияние на возможности модели. еще лучше, essay создать версию VGG-19 этой модели.