Создание базовой нейронной сети с помощью PyTorch: пошаговое руководство

Будучи студентом компьютерной инженерии, я всегда ищу способы улучшить свои навыки и углубить свои знания. В последнее время я сосредоточился на изучении PyTorch, мощной среды глубокого обучения. Чтобы закрепить то, что я узнал на данный момент, и потенциально помочь другим, кто плохо знаком с PyTorch, я решил написать этот пост в блоге с подробным описанием шагов, связанных с созданием базовой нейронной сети с использованием PyTorch. Я надеюсь, что вы найдете его полезным и информативным. Давайте погрузимся!

Прежде чем мы начнем, я хочу отдать должное там, где это необходимо. Я изучал PyTorch, просматривая видео Аладдина Перссона на YouTube и читая его сообщения в блоге на Medium. Его четкие объяснения и примеры были неоценимы в моем учебном процессе, и я настоятельно рекомендую его материалы всем, кто интересуется глубоким обучением с помощью PyTorch. Вы можете найти его блог по адресу https://aladdinpersson.medium.com/ и его канал на YouTube по адресу https://www.youtube.com/@AladdinPersson. Спасибо, Аладдин, за то, что поделились своими знаниями и помогли мне в моем путешествии по PyTorch!

1 - Импорт:

Первым шагом в построении нейронной сети с PyTorch является импорт необходимых библиотек и модулей. В этом фрагменте кода мы импортируем библиотеку torch PyTorch, а также несколько других модулей, таких как nn (для определения слоев нейронной сети), optim (для определения алгоритмов оптимизации), а также datasets и transforms (для загрузки и обработки данных).

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
import torchvision.transforms as transforms

2 - Создание нейронной сети:

После того, как мы импортировали необходимые библиотеки и модули, мы можем определить нашу модель нейронной сети. В этом примере мы определяем полносвязную нейронную сеть (также известную как нейронная сеть с прямой связью), используя класс nn.Module, предоставленный PyTorch. Мы определяем два линейных слоя (nn.Linear) с 50 (вы можете использовать другое количество единиц) скрытых единиц и функцией активации ReLU (F.relu), за которой следует последний линейный слой с выходным размером, равным количеству классов, которые мы хотим предсказать. .

class NeuralNetwork(nn.Module):
    def __init__(self, input_size, num_classes):
        super(NeuralNetwork, self).__init__()
        self.fc1 = nn.Linear(in_features=input_size, out_features=50)
        self.fc2 = nn.Linear(in_features=50, out_features=num_classes)

    def forward(self, x):
        return self.fc2(F.relu(self.fc1(x)))

3 - Проверка правильной формы:

Всегда полезно проверить выходную форму нашей модели, чтобы убедиться, что она соответствует нашим ожиданиям. В этом примере мы создаем экземпляр нашей модели нейронной сети и передаем случайный входной тензор размера (64, 784), чтобы проверить выходную форму модели. Мы печатаем форму выходного тензора, используя атрибут .shape.

model = NeuralNetwork(784, 10)
x = torch.rand(64,784)
print(model(x).shape) # Output : torch.Size([64, 10])

4 - Настройка устройства:

Если у нас есть доступ к графическому процессору, мы должны использовать его для ускорения наших вычислений. В этом фрагменте кода мы устанавливаем для устройства значение "cuda", если доступен графический процессор, и "cpu" в противном случае. Это важно для того, чтобы наша модель и данные обрабатывались на правильном устройстве.

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

5 - Настройка гиперпараметров:

Прежде чем мы сможем обучить нашу нейронную сеть, нам нужно определить некоторые гиперпараметры, такие как скорость обучения, размер пакета и количество эпох. В этом примере мы определяем скорость обучения 0.001, размер пакета 64 и обучаем 10 эпох.

input_size = 784
num_classes = 10
learning_rate = 0.001
batch_size = 64
num_epochs = 10

6 - Загрузка данных:

Чтобы обучить нашу нейронную сеть, нам нужно загрузить и предварительно обработать данные обучения и тестирования. В этом примере мы используем набор данных MNIST (который содержит изображения рукописных цифр) и класс DataLoader, предоставленный PyTorch, для загрузки данных. Мы также применяем преобразование ToTensor для преобразования изображений в тензоры PyTorch.

train_data = datasets.MNIST(root = "dataset/", 
                            train=True, 
                            transform=transforms.ToTensor(), 
                            download=True
                            )

train_loader = DataLoader(dataset=train_data, 
                          batch_size=batch_size, 
                          shuffle=True
                          )

test_data = datasets.MNIST(root = "dataset/", 
                           train=False, 
                           transform=transforms.ToTensor(), 
                           download=True
                           )

test_loader = DataLoader(dataset=test_data, 
                         batch_size=batch_size, 
                         shuffle=True
                         )

7 - Инициализация сети:

После того, как мы определили нашу модель и загрузили данные, мы можем инициализировать нашу модель нейронной сети на правильном устройстве (как определено на шаге 4), используя метод .to().

model = NeuralNetwork(input_size=input_size, num_classes=num_classes).to(device)

8 - Определение потери и оптимизатора:

Чтобы обучить нашу нейронную сеть, нам нужно определить функцию потерь и алгоритм оптимизации. В этом примере мы используем функцию потерь CrossEntropyLoss и оптимизатор Adam, предоставленный PyTorch. Мы также передаем параметры модели оптимизатору с помощью метода model.parameters().

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(params= model.parameters(), lr=learning_rate)

9 - Обучение модели:

Теперь, когда мы определили нашу модель, загрузили данные и инициализировали необходимые компоненты, мы можем обучить нашу нейронную сеть, перебирая обучающие данные в пакетах и ​​обновляя параметры модели с помощью обратного распространения. В этом фрагменте кода мы перебираем обучающие данные за указанное количество эпох, что является полным проходом по всему обучающему набору данных. В каждой эпохе мы перебираем данные пакетами, используя объект загрузчика данных train_loader. Для каждого пакета мы перемещаем данные и метки на устройство (GPU или CPU) и преобразуем данные в плоский тензор формы (batch_size, input_size). Затем мы пропускаем данные через нейронную сеть и вычисляем потери, используя функцию кросс-энтропийных потерь. Мы устанавливаем градиенты оптимизатора равными нулю, вычисляем градиенты, используя обратное распространение, и обновляем параметры, используя ступенчатую функцию оптимизатора. Этот процесс повторяется до тех пор, пока мы не повторим все пакеты в наборе обучающих данных за указанное количество эпох.

for epoch in range(num_epochs):
    for batch_idx, (data, labels) in enumerate(train_loader):
        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0], -1)

        scores = model(data)
        loss = criterion(scores, labels)

        optimizer.zero_grad()
        loss.backward()

        optimizer.step()

10-Оценка модели:

После обучения модели мы можем оценить ее производительность на тестовых данных. Мы используем обученную модель для прогнозирования меток тестовых данных и сравниваем их с метками истинности. Затем мы вычисляем точность модели, разделив количество правильных прогнозов на общее количество прогнозов.

num_correct = 0
num_samples = 0
model.eval()

with torch.no_grad():
    for data, labels in test_loader:
        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0],-1)

        scores = model(data)

        _, predictions = torch.max(scores, dim=1)
        num_correct += (predictions == labels).sum()
        num_samples += predictions.size(0)

    print(f'Got {num_correct} / {num_samples} with accuracy {float(num_correct) / float(num_samples)*100:.2f}')

model.train()
Output : Got 9712 / 10000 with accuracy 97.12

Примечание. В PyTorch есть два режима модели: режим обучения и режим оценки. Метод model.eval() переводит модель в режим оценки, который отключает определенные слои или модули, такие как отсев и нормализация партии. Это важно, потому что во время оценки мы не хотим, чтобы эти слои изменяли вывод нашей модели.

С другой стороны, model.train() переводит модель в режим обучения, который включает те слои или модули, которые были отключены во время оценки. Это важно, потому что нам нужно, чтобы эти слои изучали и обновляли свои параметры в процессе обучения.

В данном коде мы сначала устанавливаем модель в режим оценки, прежде чем тестировать модель на тестовых данных. Это гарантирует, что оценка выполняется без какого-либо шума или регуляризации, применяемых такими слоями, как отсев. После завершения оценки мы возвращаем модель в режим обучения, прежде чем продолжить цикл обучения. Это обеспечивает применение необходимой регуляризации в процессе обучения.

11 - Визуализация

Давайте визуализируем несколько случайных изображений в test_loader.

import matplotlib.pyplot as plt

# Test and plot 10 random images
model.eval()
with torch.no_grad():
    fig, axs = plt.subplots(2, 5, figsize=(12, 6))
    axs = axs.flatten()

    for i, (data, labels) in enumerate(test_loader):
        if i >= 10:  # Break after 10 images
            break

        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0], -1)

        scores = model(data)

        _, predictions = torch.max(scores, dim=1)

        # Plot images and predictions
        img = data.cpu().numpy().reshape(-1, 28, 28)
        axs[i].imshow(img[0], cmap='gray')
        axs[i].set_title(f"Label: {labels[0]} - Prediction: {predictions[0]}")


    plt.tight_layout()
    plt.show()

model.train()

Здесь, если вы хотите получить полный код

# Imports
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# Create FCN
class NeuralNetwork(nn.Module):
    def __init__(self, input_size, num_classes):
        super(NeuralNetwork, self).__init__() 
        self.fc1 = nn.Linear(in_features=input_size, out_features=50)
        self.fc2 = nn.Linear(in_features=50, out_features=num_classes)

    def forward(self, x):
        return self.fc2(F.relu(self.fc1(x)))

# Checking if it is correct shape
model = NeuralNetwork(784, 10)
x = torch.rand(64,784)
print(model(x).shape)

#Set Device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') 
print(device)

#HyperParams
input_size = 784
num_classes = 10
learning_rate = 0.001
batch_size = 64
num_epochs = 1

#Loading Data
train_data = datasets.MNIST(root = "dataset/", train=True, transform=transforms.ToTensor(), download=True)
train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)

test_data = datasets.MNIST(root = "dataset/", train=False, transform=transforms.ToTensor(), download=True)
test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=True)

#Init Network
model = NeuralNetwork(input_size=input_size, num_classes=num_classes).to(device) 

#Loss and Optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(params= model.parameters(), lr=learning_rate)

#Training
for epoch in range(num_epochs):
    for batch_idx, (data, labels) in enumerate(train_loader):
        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0], -1) 

        scores = model(data)
        loss = criterion(scores, labels)

        optimizer.zero_grad() 
        loss.backward() 

        optimizer.step() 

#Test
num_correct = 0
num_samples = 0
model.eval() 

with torch.no_grad():
    for data, labels in test_loader:
        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0],-1)

        scores = model(data)

        _, predictions = torch.max(scores, dim=1)
        num_correct += (predictions == labels).sum()
        num_samples += predictions.size(0)

    print(f'Got {num_correct} / {num_samples} with accuracy {float(num_correct) / float(num_samples)*100:.2f}')

model.train()

import matplotlib.pyplot as plt

# Test and plot 10 random images
model.eval()
with torch.no_grad():
    fig, axs = plt.subplots(2, 5, figsize=(12, 6))
    axs = axs.flatten()

    for i, (data, labels) in enumerate(test_loader):
        if i >= 10:  # Break after 10 images
            break

        data = data.to(device=device)
        labels = labels.to(device=device)

        data = data.reshape(data.shape[0], -1)

        scores = model(data)

        _, predictions = torch.max(scores, dim=1)

        # Plot images and predictions
        img = data.cpu().numpy().reshape(-1, 28, 28)
        axs[i].imshow(img[0], cmap='gray')
        axs[i].set_title(f"Label: {labels[0]} - Prediction: {predictions[0]}")


    plt.tight_layout()
    plt.show()

model.train()

Заключение

В этом уроке мы увидели, как создать простую нейронную сеть для классификации изображений с помощью PyTorch. Сначала мы загрузили набор данных MNIST, а затем определили архитектуру нейронной сети. Затем мы обучили модель, используя обучающие данные, и оценили ее производительность на тестовых данных. Мы также обсудили важные концепции, такие как размещение устройств, прямые и обратные проходы, функции потерь и алгоритмы оптимизации. Этот учебник является хорошей отправной точкой для тех, кто интересуется глубоким обучением и PyTorch.

Спасибо за прочтение! Увидимся в другом контексте!