13.7 Одноступенчатое обнаружение с несколькими окнами (SSD)
В разделах 13.3–13.6 мы рассмотрели ограничивающие рамки, якорные рамки, обнаружение в нескольких масштабах и набор данных для обнаружения. Теперь мы готовы использовать эти знания, чтобы спроектировать модель обнаружения объектов: одноступенчатое обнаружение с несколькими окнами (single shot multibox detection, SSD) (Liu et al., 2016). Эта модель простая, быстрая и широко используется. Хотя это лишь один из многих методов обнаружения объектов, некоторые проектные решения и детали реализации из этого раздела применимы и к другим моделям.
13.7.1 Модель
На рис. 13.7.1 показана архитектура модели SSD. Модель в основном состоит из базовой сети, за которой следуют несколько блоков многомасштабных признаков. Базовая сеть извлекает признаки из входного изображения, поэтому в ней можно использовать глубокую свёрточную сеть. В оригинальной статье SSD базовой сетью была VGG, обрезанная перед слоем классификации (Liu et al., 2016); сейчас её также часто заменяют на ResNet. Базовую сеть можно спроектировать так, чтобы её выход имел большие высоту и ширину. Тогда на основе этой карты признаков будет создано больше якорных рамок, которые помогут обнаруживать мелкие объекты. Каждый следующий блок многомасштабных признаков уменьшает высоту и ширину карты признаков, полученной от предыдущего слоя (например, вдвое), и расширяет рецептивное поле каждого элемента карты признаков на входном изображении.
Напомним из раздела 13.5 идею обнаружения в нескольких масштабах: глубокая нейронная сеть строит иерархическое представление изображения. Карты признаков, расположенные ближе к верху рис. 13.7.1, малы, но имеют большое рецептивное поле, поэтому они подходят для обнаружения меньшего количества, но более крупных объектов. Итак, с помощью блоков многомасштабных признаков SSD создаёт якорные рамки разных размеров и обнаруживает объекты разных размеров, предсказывая классы и смещения ограничивающих рамок. Поэтому это модель обнаружения в нескольких масштабах.
Рис. 13.7.1. Модель одноступенчатого обнаружения с несколькими окнами состоит из базового блока и нескольких блоков многомасштабных признаков, соединённых последовательно
Далее мы рассмотрим детали реализации отдельных блоков на рис. 13.7.1. Сначала обсудим, как реализовать предсказание классов и ограничивающих рамок.
13.7.1.1 Слой предсказания классов
Пусть количество классов объектов равно . Тогда у якорных рамок класс, где класс 0 — фон. Пусть на некотором масштабе высота и ширина карты признаков равны и . Если с центром в каждом её элементе создать якорных рамок, то нужно классифицировать якорных рамок. Если использовать полносвязный слой для выхода, легко получить слишком много параметров модели. Вспомним метод из раздела 7.3, в котором каналы свёрточного слоя используются для вывода предсказаний классов: одноступенчатое обнаружение с несколькими окнами применяет тот же подход, чтобы снизить сложность модели.
Конкретно, слой предсказания классов использует свёрточный слой, который сохраняет высоту и ширину входа. Тогда выход и вход соответствуют друг другу по пространственным координатам карты признаков. Рассмотрим одну и ту же пространственную позицию (, ) на выходе и на входе: каналы выходной карты признаков в этой позиции содержат предсказания классов для всех якорных рамок, созданных с центром в позиции (, ) входной карты признаков. Поэтому число выходных каналов равно , и канал с индексом () соответствует предсказанию для якорной рамки с индексом и класса с индексом .
Ниже мы определяем такой слой предсказания классов; параметры num_anchors и num_classes задают и соответственно. Слой использует свёртку с заполнением 1. Высота и ширина входа и выхода этого свёрточного слоя не меняются.
MXNet:
%matplotlib inline
from d2l import mxnet as d2l
from mxnet import autograd, gluon, image, init, np, npx
from mxnet.gluon import nn
npx.set_np()
def cls_predictor(num_anchors, num_classes):
return nn.Conv2D(num_anchors * (num_classes + 1), kernel_size=3,
padding=1)
PyTorch:
%matplotlib inline
from d2l import torch as d2l
import torch
import torchvision
from torch import nn
from torch.nn import functional as F
def cls_predictor(num_inputs, num_anchors, num_classes):
return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
kernel_size=3, padding=1)
PaddlePaddle:
%matplotlib inline
from d2l import paddle as d2l
import warnings
warnings.filterwarnings("ignore")
import paddle
from paddle import nn
from paddle.nn import functional as F
import paddle.vision as paddlevision
def cls_predictor(num_inputs, num_anchors, num_classes):
return nn.Conv2D(num_inputs, num_anchors * (num_classes + 1),
kernel_size=3, padding=1)
13.7.1.2 Слой предсказания ограничивающих рамок
Слой предсказания ограничивающих рамок устроен так же, как слой предсказания классов. Единственное отличие в том, что для каждой якорной рамки здесь нужно предсказать 4 смещения, а не значений классов.
MXNet:
def bbox_predictor(num_anchors):
return nn.Conv2D(num_anchors * 4, kernel_size=3, padding=1)
PyTorch:
def bbox_predictor(num_inputs, num_anchors):
return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)
PaddlePaddle:
def bbox_predictor(num_inputs, num_anchors):
return nn.Conv2D(num_inputs, num_anchors * 4, kernel_size=3, padding=1)
13.7.1.3 Объединение предсказаний разных масштабов
Как мы уже говорили, SSD использует карты признаков разных масштабов, чтобы создавать якорные рамки и предсказывать их классы и смещения. На разных масштабах форма карт признаков или число якорных рамок с центром в одном элементе могут различаться. Поэтому формы предсказаний на разных масштабах могут отличаться.
В следующем примере мы строим для одного минибатча две карты признаков разных масштабов (Y1 и Y2), где высота и ширина Y2 вдвое меньше, чем у Y1. В качестве примера возьмём предсказание классов: допустим, каждый элемент Y1 и Y2 создаёт соответственно 5 и 3 якорные рамки. Допустим также, что число классов объектов равно 10. Тогда число каналов в выходе предсказания классов для карт признаков Y1 и Y2 равно и соответственно. Форма любого выхода — (размер батча, число каналов, высота, ширина).
MXNet:
def forward(x, block):
block.initialize()
return block(x)
Y1 = forward(np.zeros((2, 8, 20, 20)), cls_predictor(5, 10))
Y2 = forward(np.zeros((2, 16, 10, 10)), cls_predictor(3, 10))
Y1.shape, Y2.shape
PyTorch:
def forward(x, block):
return block(x)
Y1 = forward(torch.zeros((2, 8, 20, 20)), cls_predictor(8, 5, 10))
Y2 = forward(torch.zeros((2, 16, 10, 10)), cls_predictor(16, 3, 10))
Y1.shape, Y2.shape
PaddlePaddle:
def forward(x, block):
return block(x)
Y1 = forward(paddle.zeros((2, 8, 20, 20)), cls_predictor(8, 5, 10))
Y2 = forward(paddle.zeros((2, 16, 10, 10)), cls_predictor(16, 3, 10))
Y1.shape, Y2.shape
Как видно, кроме размера батча, все остальные три измерения у двух выходов разные. Чтобы объединить эти два выхода предсказаний и повысить эффективность вычислений, мы приведём тензоры к более единообразному формату.
Измерение каналов содержит предсказания для якорных рамок с одним и тем же центром. Сначала мы переносим измерение каналов в последнее место. Поскольку размер батча на разных масштабах не меняется, мы можем привести предсказания к двумерному виду (размер батча, высота × ширина × число каналов), что удобно для последующего объединения по измерению 1.
MXNet:
def flatten_pred(pred):
return npx.batch_flatten(pred.transpose(0, 2, 3, 1))
def concat_preds(preds):
return np.concatenate([flatten_pred(p) for p in preds], axis=1)
PyTorch:
def flatten_pred(pred):
return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)
def concat_preds(preds):
return torch.cat([flatten_pred(p) for p in preds], dim=1)
PaddlePaddle:
def flatten_pred(pred):
return paddle.flatten(pred.transpose([0, 2, 3, 1]), start_axis=1)
def concat_preds(preds):
return paddle.concat([flatten_pred(p) for p in preds], axis=1)
Так, хотя Y1 и Y2 различаются по числу каналов, высоте и ширине, мы всё равно можем объединить эти два выхода предсказаний для одного минибатча на двух разных масштабах.
concat_preds([Y1, Y2]).shape
13.7.1.4 Блок уменьшения высоты и ширины вдвое
Чтобы обнаруживать объекты на нескольких масштабах, мы определяем блок down_sample_blk, который уменьшает вдвое высоту и ширину входной карты признаков. По сути, этот блок устроен по образцу VGG-блока из раздела 7.2. Точнее, каждый блок уменьшения вдвое состоит из двух свёрточных слоёв с заполнением 1 и слоя максимального пулинга с шагом 2. Мы знаем, что свёрточный слой с заполнением 1 не меняет форму карты признаков. Однако последующий слой максимального пулинга уменьшает высоту и ширину входной карты признаков вдвое. Для входа и выхода этого блока, поскольку , каждый элемент выхода имеет рецептивное поле на входе. Поэтому блок уменьшения вдвое расширяет рецептивное поле каждого элемента в выходной карте признаков.
MXNet:
def down_sample_blk(num_channels):
blk = nn.Sequential()
for _ in range(2):
blk.add(nn.Conv2D(num_channels, kernel_size=3, padding=1),
nn.BatchNorm(in_channels=num_channels),
nn.Activation('relu'))
blk.add(nn.MaxPool2D(2))
return blk
PyTorch:
def down_sample_blk(in_channels, out_channels):
blk = []
for _ in range(2):
blk.append(nn.Conv2d(in_channels, out_channels,
kernel_size=3, padding=1))
blk.append(nn.BatchNorm2d(out_channels))
blk.append(nn.ReLU())
in_channels = out_channels
blk.append(nn.MaxPool2d(2))
return nn.Sequential(*blk)
PaddlePaddle:
def down_sample_blk(in_channels, out_channels):
blk = []
for _ in range(2):
blk.append(nn.Conv2D(in_channels, out_channels,
kernel_size=3, padding=1))
blk.append(nn.BatchNorm2D(out_channels))
blk.append(nn.ReLU())
in_channels = out_channels
blk.append(nn.MaxPool2D(2))
return nn.Sequential(*blk)
В следующем примере блок уменьшения вдвое меняет число входных каналов и вдвое уменьшает высоту и ширину входной карты признаков.
MXNet:
forward(np.zeros((2, 3, 20, 20)), down_sample_blk(10)).shape
PyTorch:
forward(torch.zeros((2, 3, 20, 20)), down_sample_blk(3, 10)).shape
PaddlePaddle:
forward(paddle.zeros((2, 3, 20, 20)), down_sample_blk(3, 10)).shape
13.7.1.5 Базовый блок сети
Базовый блок сети извлекает признаки из входного изображения. Для простоты вычислений мы строим небольшую базовую сеть, которая последовательно соединяет 3 блока уменьшения вдвое и постепенно удваивает число каналов. При входном изображении размером этот базовый блок выдаёт карту признаков размером ().
MXNet:
def base_net():
blk = nn.Sequential()
for num_filters in [16, 32, 64]:
blk.add(down_sample_blk(num_filters))
return blk
forward(np.zeros((2, 3, 256, 256)), base_net()).shape
PyTorch:
def base_net():
blk = []
num_filters = [3, 16, 32, 64]
for i in range(len(num_filters) - 1):
blk.append(down_sample_blk(num_filters[i], num_filters[i+1]))
return nn.Sequential(*blk)
forward(torch.zeros((2, 3, 256, 256)), base_net()).shape
PaddlePaddle:
def base_net():
blk = []
num_filters = [3, 16, 32, 64]
for i in range(len(num_filters) - 1):
blk.append(down_sample_blk(num_filters[i], num_filters[i+1]))
return nn.Sequential(*blk)
forward(paddle.zeros((2, 3, 256, 256)), base_net()).shape
13.7.1.6 Полная модель
Полная модель одноступенчатого обнаружения с несколькими окнами состоит из пяти блоков. Карта признаков, которую выдаёт каждый блок, используется и для создания якорных рамок, и для предсказания их классов и смещений. Из этих пяти блоков первый — базовый блок сети, со второго по четвёртый — блоки уменьшения вдвое, а последний блок использует глобальный максимальный пулинг, чтобы уменьшить высоту и ширину до 1. Технически блоки со второго по пятый — это блоки многомасштабных признаков с рис. 13.7.1.
MXNet:
def get_blk(i):
if i == 0:
blk = base_net()
elif i == 4:
blk = nn.GlobalMaxPool2D()
else:
blk = down_sample_blk(128)
return blk
PyTorch:
def get_blk(i):
if i == 0:
blk = base_net()
elif i == 1:
blk = down_sample_blk(64, 128)
elif i == 4:
blk = nn.AdaptiveMaxPool2d((1,1))
else:
blk = down_sample_blk(128, 128)
return blk
PaddlePaddle:
def get_blk(i):
if i == 0:
blk = base_net()
elif i == 1:
blk = down_sample_blk(64, 128)
elif i == 4:
blk = nn.AdaptiveMaxPool2D((1,1))
else:
blk = down_sample_blk(128, 128)
return blk
Теперь определим прямое распространение для каждого блока. В отличие от задачи классификации изображений, выход здесь включает: карту признаков Y свёрточной сети; якорные рамки, созданные по Y на текущем масштабе; предсказанные по Y классы и смещения этих якорных рамок.
MXNet:
def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
Y = blk(X)
anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
cls_preds = cls_predictor(Y)
bbox_preds = bbox_predictor(Y)
return (Y, anchors, cls_preds, bbox_preds)
PyTorch:
def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
Y = blk(X)
anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
cls_preds = cls_predictor(Y)
bbox_preds = bbox_predictor(Y)
return (Y, anchors, cls_preds, bbox_preds)
PaddlePaddle:
def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
Y = blk(X)
anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
cls_preds = cls_predictor(Y)
bbox_preds = bbox_predictor(Y)
return (Y, anchors, cls_preds, bbox_preds)
Напомним, что на рис. 13.7.1 блок многомасштабных признаков ближе к верху предназначен для обнаружения крупных объектов, поэтому ему нужны якорные рамки большего размера. В приведённом выше прямом распространении для каждого блока многомасштабных признаков мы передаём в функцию multibox_prior через параметр sizes список из двух значений масштаба. Ниже интервал от 0.2 до 1.05 равномерно делится на пять частей, чтобы задать меньшие значения масштаба для пяти блоков: 0.2, 0.37, 0.54, 0.71 и 0.88. Большие значения масштаба для каждого блока вычисляются как , и так далее.
sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
[0.88, 0.961]]
ratios = [[1, 2, 0.5]] * 5
num_anchors = len(sizes[0]) + len(ratios[0]) - 1
Теперь мы можем определить полную модель TinySSD следующим образом.
MXNet:
class TinySSD(nn.Block):
def __init__(self, num_classes, **kwargs):
super(TinySSD, self).__init__(**kwargs)
self.num_classes = num_classes
for i in range(5):
# Эквивалентно присваиванию self.blk_i = get_blk(i)
setattr(self, f'blk_{i}', get_blk(i))
setattr(self, f'cls_{i}', cls_predictor(num_anchors, num_classes))
setattr(self, f'bbox_{i}', bbox_predictor(num_anchors))
def forward(self, X):
anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
for i in range(5):
# getattr(self, 'blk_%d' % i) — это обращение к self.blk_i
X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
anchors = np.concatenate(anchors, axis=1)
cls_preds = concat_preds(cls_preds)
cls_preds = cls_preds.reshape(
cls_preds.shape[0], -1, self.num_classes + 1)
bbox_preds = concat_preds(bbox_preds)
return anchors, cls_preds, bbox_preds
PyTorch:
class TinySSD(nn.Module):
def __init__(self, num_classes, **kwargs):
super(TinySSD, self).__init__(**kwargs)
self.num_classes = num_classes
idx_to_in_channels = [64, 128, 128, 128, 128]
for i in range(5):
# Эквивалентно присваиванию self.blk_i = get_blk(i)
setattr(self, f'blk_{i}', get_blk(i))
setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],
num_anchors, num_classes))
setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],
num_anchors))
def forward(self, X):
anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
for i in range(5):
# getattr(self, 'blk_%d' % i) — это обращение к self.blk_i
X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
anchors = torch.cat(anchors, dim=1)
cls_preds = concat_preds(cls_preds)
cls_preds = cls_preds.reshape(
cls_preds.shape[0], -1, self.num_classes + 1)
bbox_preds = concat_preds(bbox_preds)
return anchors, cls_preds, bbox_preds
PaddlePaddle:
class TinySSD(nn.Layer):
def __init__(self, num_classes, **kwargs):
super(TinySSD, self).__init__(**kwargs)
self.num_classes = num_classes
idx_to_in_channels = [64, 128, 128, 128, 128]
for i in range(5):
# Эквивалентно присваиванию self.blk_i = get_blk(i)
setattr(self, f'blk_{i}', get_blk(i))
setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],
num_anchors, num_classes))
setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],
num_anchors))
def forward(self, X):
anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
for i in range(5):
# getattr(self, 'blk_%d' % i) — это обращение к self.blk_i
X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
anchors = paddle.concat(anchors, axis=1)
cls_preds = concat_preds(cls_preds)
cls_preds = cls_preds.reshape(
(cls_preds.shape[0], -1, self.num_classes + 1))
bbox_preds = concat_preds(bbox_preds)
return anchors, cls_preds, bbox_preds
Создадим экземпляр модели и выполним прямое распространение для минибатча изображений X размером пикселей.
Как показано выше, первый блок выдаёт карту признаков размером . Напомним, что со второго по четвёртый блоки — это блоки уменьшения вдвое, а пятый блок — глобальный слой пулинга. Поскольку с центром в каждом элементе карты признаков создаются 4 якорные рамки, на всех пяти масштабах для одного изображения получается якорных рамок.
MXNet:
net = TinySSD(num_classes=1)
net.initialize()
X = np.zeros((32, 3, 256, 256))
anchors, cls_preds, bbox_preds = net(X)
print('выходные якорные рамки:', anchors.shape)
print('выход предсказаний классов:', cls_preds.shape)
print('выход предсказаний рамок:', bbox_preds.shape)
PyTorch:
net = TinySSD(num_classes=1)
X = torch.zeros((32, 3, 256, 256))
anchors, cls_preds, bbox_preds = net(X)
print('выходные якорные рамки:', anchors.shape)
print('выход предсказаний классов:', cls_preds.shape)
print('выход предсказаний рамок:', bbox_preds.shape)
PaddlePaddle:
net = TinySSD(num_classes=1)
X = paddle.zeros((32, 3, 256, 256))
anchors, cls_preds, bbox_preds = net(X)
print('выходные якорные рамки:', anchors.shape)
print('выход предсказаний классов:', cls_preds.shape)
print('выход предсказаний рамок:', bbox_preds.shape)
13.7.2 Обучение модели
Теперь опишем, как обучать модель одноступенчатого обнаружения с несколькими окнами для обнаружения объектов.
13.7.2.1 Чтение набора данных и инициализация
Сначала загрузим набор данных для обнаружения бананов, описанный в разделе 13.6.
batch_size = 32
train_iter, _ = d2l.load_data_bananas(batch_size)
В наборе данных для обнаружения бананов у объектов один класс. После определения модели нужно инициализировать её параметры и задать алгоритм оптимизации.
MXNet:
device, net = d2l.try_gpu(), TinySSD(num_classes=1)
net.initialize(init=init.Xavier(), ctx=device)
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': 0.2, 'wd': 5e-4})
PyTorch:
device, net = d2l.try_gpu(), TinySSD(num_classes=1)
trainer = torch.optim.SGD(net.parameters(), lr=0.2, weight_decay=5e-4)
PaddlePaddle:
device, net = d2l.try_gpu(), TinySSD(num_classes=1)
trainer = paddle.optimizer.SGD(learning_rate=0.2,
parameters=net.parameters(),
weight_decay=5e-4)
13.7.2.2 Определение функций потерь и оценки
Для обнаружения объектов есть два типа потерь. Первый — потеря, связанная с классами якорных рамок: её можно вычислить с помощью функции кросс-энтропии, которую мы использовали в задачах классификации. Второй — потеря, связанная со смещениями положительных якорных рамок: предсказание смещений — это задача регрессии. Однако здесь для этой задачи мы не используем квадратичную потерю из раздела 3.1, а берём потерю в норме , то есть модуль разности предсказанного и истинного значений. Маска bbox_masks исключает из вычисления потерь отрицательные и фиктивные (дополняющие) якорные рамки. Наконец, мы складываем потери классов и смещений якорных рамок и получаем итоговую функцию потерь модели.
MXNet:
cls_loss = gluon.loss.SoftmaxCrossEntropyLoss()
bbox_loss = gluon.loss.L1Loss()
def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
cls = cls_loss(cls_preds, cls_labels)
bbox = bbox_loss(bbox_preds * bbox_masks, bbox_labels * bbox_masks)
return cls + bbox
PyTorch:
cls_loss = nn.CrossEntropyLoss(reduction='none')
bbox_loss = nn.L1Loss(reduction='none')
def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
batch_size, num_classes = cls_preds.shape[0], cls_preds.shape[2]
cls = cls_loss(cls_preds.reshape(-1, num_classes),
cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1)
bbox = bbox_loss(bbox_preds * bbox_masks,
bbox_labels * bbox_masks).mean(dim=1)
return cls + bbox
PaddlePaddle:
cls_loss = nn.CrossEntropyLoss(reduction='none')
bbox_loss = nn.L1Loss(reduction='none')
def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
batch_size, num_classes = cls_preds.shape[0], cls_preds.shape[2]
cls = cls_loss(cls_preds.reshape((-1, num_classes)),
cls_labels.reshape([-1])).reshape((batch_size, -1)).mean(axis=1)
bbox = bbox_loss(bbox_preds * bbox_masks,
bbox_labels * bbox_masks).mean(axis=1)
return cls + bbox
Для оценки результатов классификации можно использовать точность. Поскольку для смещений применяется потеря в норме , для оценки предсказаний ограничивающих рамок мы используем среднюю абсолютную ошибку (mean absolute error). Эти предсказания получаются из созданных якорных рамок и их предсказанных смещений.
MXNet:
def cls_eval(cls_preds, cls_labels):
# Поскольку предсказания классов находятся в последнем измерении, в argmax нужно указать последнее измерение.
return float((cls_preds.argmax(axis=-1).astype(
cls_labels.dtype) == cls_labels).sum())
def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
return float((np.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())
PyTorch:
def cls_eval(cls_preds, cls_labels):
# Поскольку предсказания классов находятся в последнем измерении, в argmax нужно указать последнее измерение.
return float((cls_preds.argmax(dim=-1).type(
cls_labels.dtype) == cls_labels).sum())
def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
return float((torch.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())
PaddlePaddle:
def cls_eval(cls_preds, cls_labels):
# Поскольку предсказания классов находятся в последнем измерении, в argmax нужно указать последнее измерение.
return float((cls_preds.argmax(axis=-1).astype(
cls_labels.dtype) == cls_labels).sum())
def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
return float((paddle.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())
13.7.2.3 Обучение модели
При обучении модели в прямом распространении мы генерируем многомасштабные якорные рамки (anchors) и предсказываем их классы (cls_preds) и смещения (bbox_preds). Затем по разметке Y мы размечаем классы (cls_labels) и смещения (bbox_labels) якорных рамок. В конце мы вычисляем функцию потерь по предсказанным и размеченным классам и смещениям. Для краткости тестовый набор данных здесь не оценивается.
MXNet:
num_epochs, timer = 20, d2l.Timer()
animator = d2l.Animator(xlabel='эпоха', xlim=[1, num_epochs],
legend=['ошибка классов', 'MAE рамок'])
for epoch in range(num_epochs):
# Метрики: сумма верных предсказаний классов, число предсказаний классов,
# сумма абсолютных ошибок рамок, число значений в этой сумме
metric = d2l.Accumulator(4)
for features, target in train_iter:
timer.start()
X = features.as_in_ctx(device)
Y = target.as_in_ctx(device)
with autograd.record():
# Генерируем многомасштабные якорные рамки и предсказываем для каждой из них класс и смещение
anchors, cls_preds, bbox_preds = net(X)
# Размечаем классы и смещения для каждой якорной рамки
bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors,
Y)
# По предсказанным и размеченным классам и смещениям вычисляем функцию потерь
l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
bbox_masks)
l.backward()
trainer.step(batch_size)
metric.add(cls_eval(cls_preds, cls_labels), cls_labels.size,
bbox_eval(bbox_preds, bbox_labels, bbox_masks),
bbox_labels.size)
cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
animator.add(epoch + 1, (cls_err, bbox_mae))
print(f'ошибка классов {cls_err:.2e}, MAE рамок {bbox_mae:.2e}')
print(f'{len(train_iter._dataset) / timer.stop():.1f} примеров/с на '
f'{str(device)}')
PyTorch:
num_epochs, timer = 20, d2l.Timer()
animator = d2l.Animator(xlabel='эпоха', xlim=[1, num_epochs],
legend=['ошибка классов', 'MAE рамок'])
net = net.to(device)
for epoch in range(num_epochs):
# Сумма верных предсказаний классов, число предсказаний классов,
# сумма абсолютных ошибок рамок, число значений в этой сумме
metric = d2l.Accumulator(4)
net.train()
for features, target in train_iter:
timer.start()
trainer.zero_grad()
X, Y = features.to(device), target.to(device)
# Генерируем многомасштабные якорные рамки и предсказываем для каждой из них класс и смещение
anchors, cls_preds, bbox_preds = net(X)
# Размечаем классы и смещения для каждой якорной рамки
bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)
# По предсказанным и размеченным классам и смещениям вычисляем функцию потерь
l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
bbox_masks)
l.mean().backward()
trainer.step()
metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),
bbox_eval(bbox_preds, bbox_labels, bbox_masks),
bbox_labels.numel())
cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
animator.add(epoch + 1, (cls_err, bbox_mae))
print(f'ошибка классов {cls_err:.2e}, MAE рамок {bbox_mae:.2e}')
print(f'{len(train_iter.dataset) / timer.stop():.1f} примеров/с на '
f'{str(device)}')
PaddlePaddle:
num_epochs, timer = 20, d2l.Timer()
animator = d2l.Animator(xlabel='эпоха', xlim=[1, num_epochs],
legend=['ошибка классов', 'MAE рамок'])
for epoch in range(num_epochs):
# Сумма верных предсказаний классов, число предсказаний классов,
# сумма абсолютных ошибок рамок, число значений в этой сумме
metric = d2l.Accumulator(4)
net.train()
for features, target in train_iter:
timer.start()
trainer.clear_grad()
X, Y = features, target
# Генерируем многомасштабные якорные рамки и предсказываем для каждой из них класс и смещение
anchors, cls_preds, bbox_preds = net(X)
# Размечаем классы и смещения для каждой якорной рамки
bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)
# По предсказанным и размеченным классам и смещениям вычисляем функцию потерь
l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
bbox_masks)
l.mean().backward()
trainer.step()
metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),
bbox_eval(bbox_preds, bbox_labels, bbox_masks),
bbox_labels.numel())
cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
animator.add(epoch + 1, (cls_err, bbox_mae))
print(f'ошибка классов {cls_err:.2e}, MAE рамок {bbox_mae:.2e}')
print(f'{len(train_iter.dataset) / timer.stop():.1f} примеров/с на '
f'{str(device)}')
13.7.3 Предсказание объектов
На этапе предсказания мы хотим найти все интересующие нас объекты на изображении. Ниже мы загружаем тестовое изображение, меняем его размер и приводим к четырёхмерному формату, который нужен свёрточным слоям.
MXNet:
img = image.imread('../img/banana.jpg')
feature = image.imresize(img, 256, 256).astype('float32')
X = np.expand_dims(feature.transpose(2, 0, 1), axis=0)
PyTorch:
X = torchvision.io.read_image('../img/banana.jpg').unsqueeze(0).float()
img = X.squeeze(0).permute(1, 2, 0).long()
PaddlePaddle:
X = paddle.to_tensor(
paddlevision.image.image_load(
'../img/banana.jpg', backend="cv2"
)[..., ::-1].transpose([2,0,1])
).unsqueeze(0).astype(paddle.float32)
img = X.squeeze(0).transpose([1, 2, 0]).astype(paddle.int64)
С помощью функции multibox_detection ниже мы по якорным рамкам и их предсказанным смещениям получаем предсказанные ограничивающие рамки. Затем с помощью подавления немаксимумов удаляем похожие предсказанные рамки.
MXNet:
def predict(X):
anchors, cls_preds, bbox_preds = net(X.as_in_ctx(device))
cls_probs = npx.softmax(cls_preds).transpose(0, 2, 1)
output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
return output[0, idx]
output = predict(X)
PyTorch:
def predict(X):
net.eval()
anchors, cls_preds, bbox_preds = net(X.to(device))
cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1)
output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
return output[0, idx]
output = predict(X)
PaddlePaddle:
def predict(X):
net.eval()
anchors, cls_preds, bbox_preds = net(X)
cls_probs = F.softmax(cls_preds, axis=2).transpose([0, 2, 1])
output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
return output[0, :][idx]
output = predict(X)
Наконец, выведем все ограничивающие рамки с уверенностью не ниже 0.9 как итоговый результат.
MXNet:
def display(img, output, threshold):
d2l.set_figsize((5, 5))
fig = d2l.plt.imshow(img.asnumpy())
for row in output:
score = float(row[1])
if score < threshold:
continue
h, w = img.shape[0:2]
bbox = [row[2:6] * np.array((w, h, w, h), ctx=row.ctx)]
d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
display(img, output, threshold=0.9)
PyTorch:
def display(img, output, threshold):
d2l.set_figsize((5, 5))
fig = d2l.plt.imshow(img)
for row in output:
score = float(row[1])
if score < threshold:
continue
h, w = img.shape[0:2]
bbox = [row[2:6] * torch.tensor((w, h, w, h), device=row.device)]
d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
display(img, output.cpu(), threshold=0.9)
PaddlePaddle:
def display(img, output, threshold):
d2l.set_figsize((5, 5))
fig = d2l.plt.imshow(img)
for row in output:
score = float(row[1])
if score < threshold:
continue
h, w = img.shape[0:2]
bbox = [row[2:6] * paddle.to_tensor((w, h, w, h))]
d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
display(img, output.cpu(), threshold=0.9)
Резюме
- Одноступенчатое обнаружение с несколькими окнами — это модель обнаружения в нескольких масштабах. На основе базового блока сети и нескольких блоков многомасштабных признаков SSD создаёт якорные рамки разного числа и размера и обнаруживает объекты разного размера, предсказывая классы и смещения этих якорных рамок.
- При обучении модели одноступенчатого обнаружения с несколькими окнами функция потерь вычисляется по предсказанным и размеченным классам и смещениям якорных рамок.
Упражнения
- Можно ли улучшить одноступенчатое обнаружение с несколькими окнами, изменив функцию потерь? Например, заменить потерю в норме , которую мы используем для предсказания смещений, на сглаженную потерю в норме . Вблизи нуля она использует квадратичную функцию и поэтому становится более гладкой. Эта гладкость задаётся гиперпараметром :
При очень большом эта потеря похожа на потерю в норме . Когда значение мало, функция потерь становится более гладкой.
MXNet:
sigmas = [10, 1, 0.5]
lines = ['-', '--', '-.']
x = np.arange(-2, 2, 0.1)
d2l.set_figsize()
for l, s in zip(lines, sigmas):
y = npx.smooth_l1(x, scalar=s)
d2l.plt.plot(x.asnumpy(), y.asnumpy(), l, label='sigma=%.1f' % s)
d2l.plt.legend();
PyTorch:
def smooth_l1(data, scalar):
out = []
for i in data:
if abs(i) < 1 / (scalar ** 2):
out.append(((scalar * i) ** 2) / 2)
else:
out.append(abs(i) - 0.5 / (scalar ** 2))
return torch.tensor(out)
sigmas = [10, 1, 0.5]
lines = ['-', '--', '-.']
x = torch.arange(-2, 2, 0.1)
d2l.set_figsize()
for l, s in zip(lines, sigmas):
y = smooth_l1(x, scalar=s)
d2l.plt.plot(x, y, l, label='sigma=%.1f' % s)
d2l.plt.legend();
PaddlePaddle:
def smooth_l1(data, scalar):
out = []
for i in data.numpy():
if abs(i) < 1 / (scalar ** 2):
out.append(((scalar * i) ** 2) / 2)
else:
out.append(abs(i) - 0.5 / (scalar ** 2))
return paddle.to_tensor(out)
sigmas = [10, 1, 0.5]
lines = ['-', '--', '-.']
x = paddle.arange(-2.0, 2.0, 0.1, dtype=paddle.float32)
d2l.set_figsize()
for l, s in zip(lines, sigmas):
y = smooth_l1(x, scalar=s)
d2l.plt.plot(x, y, l, label='sigma=%.1f' % s)
d2l.plt.legend();
Кроме того, для предсказания классов в эксперименте использовалась кросс-энтропия: если предсказанная вероятность истинного класса равна , то потеря равна . Также можно использовать фокальную потерю (Lin et al., 2017). При заданных гиперпараметрах и эта потеря определяется так:
Видно, что увеличение эффективно уменьшает относительную потерю для примеров с большой предсказанной вероятностью правильного класса (например, ), поэтому обучение может сосредоточиться на трудных примерах, которые классифицируются неверно.
MXNet:
def focal_loss(gamma, x):
return -(1 - x) ** gamma * np.log(x)
x = np.arange(0.01, 1, 0.01)
for l, gamma in zip(lines, [0, 1, 5]):
y = d2l.plt.plot(x.asnumpy(), focal_loss(gamma, x).asnumpy(), l,
label='gamma=%.1f' % gamma)
d2l.plt.legend();
PyTorch:
def focal_loss(gamma, x):
return -(1 - x) ** gamma * torch.log(x)
x = torch.arange(0.01, 1, 0.01)
for l, gamma in zip(lines, [0, 1, 5]):
y = d2l.plt.plot(x, focal_loss(gamma, x), l, label='gamma=%.1f' % gamma)
d2l.plt.legend();
PaddlePaddle:
def focal_loss(gamma, x):
return -(1 - x) ** gamma * paddle.log(x)
x = paddle.arange(0.01, 1, 0.01, dtype=paddle.float32)
for l, gamma in zip(lines, [0, 1, 5]):
y = d2l.plt.plot(x, focal_loss(gamma, x), l, label='gamma=%.1f' % gamma)
d2l.plt.legend();
- Из-за ограничений объёма в этом разделе мы опустили некоторые детали реализации модели одноступенчатого обнаружения с несколькими окнами. Можно ли улучшить модель в следующих направлениях:
- когда объекты намного меньше изображения, модель может увеличить входное изображение;
- обычно есть много отрицательных якорных рамок. Чтобы распределение классов было более сбалансированным, можно уменьшить вдвое высоту и ширину отрицательных якорных рамок;
- в функции потерь задать гиперпараметры, которые по-разному взвешивают потерю классов и потерю смещений;
- оценивать модель обнаружения объектов другими методами, например теми, что описаны в статье об одноступенчатом обнаружении с несколькими окнами (Liu et al., 2016).
MXNet: Обсуждение
PyTorch: Обсуждение
PaddlePaddle: Обсуждение
Литература
- Liu, W., Anguelov, D., Erhan, D., Szegedy, C., Reed, S., Fu, C.-Y., & Berg, A. C. (2016). SSD: Single shot multibox detector. European Conference on Computer Vision, 21–37.