В предыдущих постах мы рассмотрели, как определить нейронные сети, вычислить потери и сделать обновления весов сети.
Теперь можно задуматься,
А как насчет данных?
Как правило, когда вам приходится иметь дело с изображениями, текстом, аудио или видео данными, вы можете использовать стандартные Python пакеты, которые загружают данные в NumPy массив. Затем вы можете преобразовать этот массив в torch.*Tensor.
- Для изображений полезны такие пакеты, как Pillow, OpenCV
- Для аудио, такие пакеты, как scipy и librosa
- Для текста - либо загрузка на основе Python, либо на основе Cython, либо NLTK и SpaCy будут полезны
Специально для изображений существует пакет под названием torchvision, в котором есть загрузчики данных для общераспространенных наборов данных, таких как Imagenet, CIFAR10, MNIST и т.д. И преобразователи данных для изображений, а именно, torchvision.datasets и torch.utils.data.DataLoader.
Эти пакеты дают огромное преимущество и позволяют избежать написания стандартного кода.
В этом посте мы будем использовать набор данных CIFAR10. У него есть классы: ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’. Изображения в CIFAR-10 имеют размер 3x32x32, то есть 3-канальные цветные изображения размером 32x32 пикселей.
Создание классификатора изображений
Мы выполним следующие шаги по порядку:
- Загрузим и нормализуем обучающие и тестовые наборы данных CIFAR10, используя
torchvision - Определим сверточную нейронную сеть
- Определим функцию потерь
- Обучим сеть на тренировочных данных
- Протестируем сеть на тестовых данных
1. Загрузка и нормализация CIFAR10
Используя torchvision, загрузить CIFAR10 крайне просто.
import torch
import torchvision
import torchvision.transforms as transforms
Выходные данные torchvision наборов данных представляют собой изображения PILImage диапазона [0, 1]. Мы преобразуем их в тензоры нормализованного диапазона [-1, 1].
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
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')
Вывод:
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
to ./data/cifar-10-python.tar.gz
Files already downloaded and verified
Выведем несколько тренировочных изображений:
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
# функция для показа изображения
def imshow(img):
img = img / 2 + 0.5 # денормализуем
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# получаем несколько случайных тренировочных изображений
dataiter = iter(trainloader)
images, labels = dataiter.next()
# показываем изображения
imshow(torchvision.utils.make_grid(images))
# печатаем метки
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
Вывод:
cat plane ship frog
2. Определяем сверточную нейронную сеть
Скопируем нейронную сеть из предыдущего поста и модифицируем ее для приема 3-канальных изображений (вместо 1-канальных изображений как было определено).
import torch.nn as nn
import torch.nn.functional as F
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()
3. Определяем функцию потери и оптимизатор
Будем использовать классификацию кросс-энтропийных потерь и SGD с импульсом.
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
4. Тренировка сети
Для тренировки сети нам просто нужно пройти цикл нашего итератора данных и передать вводные данные в сеть и оптимизировать.
# -*- coding: utf-8 -*-
# проходим в цикле по набору данных несколько раз
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# получаем вводные данные
inputs, labels = data
# обнуляем параметр gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# печатаем статистику
running_loss += loss.item()
if i % 2000 == 1999: # печатаем каждые 2000 мини-пакетов
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Тренировка завершена')
Вывод:
[1, 2000] loss: 2.187
[1, 4000] loss: 1.852
[1, 6000] loss: 1.672
[1, 8000] loss: 1.566
[1, 10000] loss: 1.490
[1, 12000] loss: 1.461
[2, 2000] loss: 1.389
[2, 4000] loss: 1.364
[2, 6000] loss: 1.343
[2, 8000] loss: 1.318
[2, 10000] loss: 1.282
[2, 12000] loss: 1.286
Тренировка завершена
5. Тестируем сеть с помощью тестовых данных
Мы обучили сеть за 2 прохода по набору тренировочных данных. Но нам нужно проверить, научилась ли сеть вообще чему-либо.
Мы проверим это, спрогнозировав метку класса, которую выдает нейронная сеть, и проверим ее на основании истины. Если прогноз правильный, мы добавляем пример в список правильных прогнозов.
Хорошо, первый шаг. Давайте покажем изображение из тестового набора для ознакомления.
dataiter = iter(testloader)
images, labels = dataiter.next()
# печатаем изображения
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ',
' '.join('%5s' % classes[labels[j]] for j in range(4)))
Вывод:
GroundTruth: cat ship ship plane
Теперь посмотрим, что нейронная сеть думает об этих примерах:
outputs = net(images)
Выводы - это рассчитанные вероятности для 10 классов. Чем больше вероятность для класса, тем вероятнее нейронная сеть предполагает, что изображение принадлежит этому классу. Таким образом, возьмем индекс наибольшей вероятности:
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
Вывод:
Predicted: cat ship car ship
Результаты кажутся весьма хорошими.
Посмотрим как сеть отработает на целом наборе данных.
# -*- coding: utf-8 -*-
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('Аккуратность сети на 10000 тестовых изображений: %d %%' % (
100 * correct / total))
Вывод:
Аккуратность сети на 10000 тестовых изображений: 54 %
Это выглядит лучше, чем простой случай, где аккуратность 10% (выбор класса из 10 классов случайным образом). Кажется сеть обучилась чему-то.
Посмотрим на каких классах прогнозы выполнились хорошо, а на каких не очень хорошо:
# -*- coding: utf-8 -*-
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Аккуратность %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
Вывод:
Аккуратность plane : 57 %
Аккуратность car : 73 %
Аккуратность bird : 49 %
Аккуратность cat : 54 %
Аккуратность deer : 18 %
Аккуратность dog : 20 %
Аккуратность frog : 58 %
Аккуратность horse : 74 %
Аккуратность ship : 70 %
Аккуратность truck : 66 %
Тренировка на GPU
Также как тензор перемещается на GPU, также и сеть можно просто переместить на GPU.
Сначала зададим устройство как первое видимое CUDA устройство, если CUDA доступно:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Предполгаем, что у нас CUDA машина,
# поэтому должно напечататься CUDA устройство:
print(device)
Вывод:
cuda:0
В следующих примерах предполагается, что устройство является CUDA устройством.
Тогда этот метод будет рекурсивно проходить по всем модулям и преобразовывать их параметры и буфферы в CUDA тензоры:
net.to(device)
Необходимо помнить, что требуется отправлять вводные данные и цели на каждом шагу также в GPU:
inputs, labels = inputs.to(device), labels.to(device)
На самом деле здесь не будет значительного увеличения скорости по сравнению с выполнением в CPU, потому что наша сеть очень мала.
Читайте также другие статьи в блоге: