Краткий обзор алгоритмов обнаружения объектов.

Понимание фреймворков обнаружения объектов и их недавнего развития.

Команда машинного зрения @Fractal Analytics работает над решением нескольких задач по обнаружению объектов. Мы использовали множество фреймворков, доступных в сообществе разработчиков ПО с открытым исходным кодом, и модифицировали их в соответствии с нашими вариантами использования для создания приложений для различных постановок задач. Мы создали алгоритмы для работы с различными наборами данных изображений, такими как изображения естественного ландшафта, изображения пробок на дорогах, спутниковые изображения, изображения магазинов розничной торговли, изображения проходов и другие. Мы также использовали нашу структуру обнаружения объектов для улучшения некоторых наших решений по классификации видео и изображений - мы заметили, что использование подхода с использованием нескольких методов дало нам лучшие результаты.

Несмотря на то, что в Интернете доступно множество материалов, все еще довольно сложно понять, с чего начать обнаружение объектов. В этом блоге будет задокументировано много информации, которую мы узнали в этом путешествии, и он будет очень полезен для тех, кто хочет начать изучение обнаружения объектов.

Обнаружение объектов по-прежнему является относительно нерешенной проблемой в машинном зрении, и ожидается, что в ближайшие несколько лет будет внесено множество улучшений. В то время как уровень точности классификации изображений приближается к «пятерке основных ошибок» в 2,25% по вызову ImageNet, и сообщество в целом заявило о достижении точности классификации «выше человеческого», алгоритмы обнаружения объектов все еще находятся на ранних стадиях разработки. , с современными алгоритмами обнаружения объектов, достигающими только 40,8 MAP (100 - максимум) на наборе данных COCO. В таких ситуациях понимание того, где алгоритмы обнаружения объектов не работают, и тщательный подбор наборов данных для конкретного варианта использования - это хорошо соблюдаемый подход для достижения оптимальных результатов.

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

Мы обсудим следующие ключевые алгоритмы обнаружения объектов:

Эволюция методов обнаружения объектов

Традиционно обнаружение объектов реализовывалось с использованием простых методов сопоставления шаблонов. В этих методах целевые объекты использовались для обрезки и с использованием определенных дескрипторов, таких как HOG и SIFT, для их создания использовались функции. Впоследствии этот подход использовал скользящее окно на изображении и сравнивал каждое местоположение с базой данных векторов признаков объекта. В усовершенствованных алгоритмах используются классификаторы, такие как обученные классификаторы SVM, чтобы заменить использование этих баз данных. Поскольку объекты будут разных размеров, люди использовали разные размеры окон и изображений (пирамиды изображений). Эти сложные конвейеры частично решали проблему обнаружения объектов, но имели много недостатков. Конвейеры требовали вычислительных затрат времени, а функции, созданные вручную с использованием таких алгоритмов, как HOG и SIFT, не были очень точными.

С появлением использования глубокого обучения в машинном зрении и ошеломляющих результатов, полученных этими алгоритмами для задач классификации изображений в 2012 году, исследователи начали искать решения глубокого обучения для решения проблем обнаружения объектов. Одним из первых важных алгоритмов для решения проблемы обнаружения объектов с использованием глубокого обучения был R-CNN (региональные предложения с CNN).

R-CNN

Это первая статья, показывающая, что CNN может значительно повысить производительность обнаружения объектов. Он достиг 58,5 MAP по набору данных VOC 2007.

Чтобы построить конвейер обнаружения объектов R-CNN, можно использовать следующий подход.

Подход начинается со стандартной сети, такой как VGG или ResNet, предварительно обученной в Image-net - эта сеть будет действовать как средство извлечения признаков для изображения. Этот подход удаляет слой классификации, специфичный для класса, и использует слой узких мест для извлечения функций из изображения. В R-CNN подход использует сеть VGG, и мы получаем вектор размером 4096 тусклых пикселей для каждого предложения изображения.

Убедитесь, что объекты извлечены точно, они тренируют сеть, используя эти искаженные изображения. При обучении набора данных VOC они размещают слой 20 + 1 (n_class + background) в конце и обучают сеть. Каждый размер пакета содержит 32 положительных окна и 96 фоновых окон. Предложение региона считается положительным, если оно имеет IoU ≥ 0,5 с наземным блоком истинности. Обычно получают эти 128 (32 + 96) предложений из 2 изображений (размер партии). Поскольку будет ~ 2k предложений от каждого изображения, мы отбираем позитивные изображения и негативные изображения (фоновые) изображения отдельно. Мы используем выборочный поиск для создания этих предложений.
После тонкой настройки сети мы разошлем предложения по сети и получим 4096 тусклый вектор. Авторы этой статьи выполнили поиск по сетке долговых обязательств, чтобы выбрать положительные образцы, долговые обязательства 0,3 сработали для них.
Для каждого класса объектов обучите классификатор SVM (один против другого). Вы можете использовать жесткий отрицательный анализ, чтобы повысить точность классификации.
Мы также обучаем регрессоры ограничивающего прямоугольника, чтобы исправить ошибки локализации. Это применяется к предложению после того, как классификатор SVM классифицирует объект.

Тестирование алгоритма

Для тестирования R-CNN генерирует около 2000 независимых от категорий предложений регионов из входного изображения, извлекает вектор признаков фиксированной длины для каждого предложения с помощью CNN (VGG Net), а затем классифицирует каждый регион с помощью линейных SVM, зависящих от категории. Это дает каждому предложению оценку «объектности» для конкретного класса, которая затем отправляется алгоритму подавления, не являющегося максимальным.
Вывод времени тестирования занимает 13 секунд на изображение на GPU и 53 секунды на изображение на CPU.

Основные проблемы этого подхода:

Отправка ~ 2000 предложений в нейронную сеть, тем самым доведя время тестирования до 13 секунд на GPU.
Сложный конвейер для обучения и вывода. Нет непрерывного учебного процесса. Нейронная сеть обучается отдельно, классификаторы SVM обучаются индивидуально (в сети SPP они немного преодолены)

СПП-Нет

Основная проблема с R-CNN - это вычисление вектора характеристик для ~ 2000 предложений по отдельности путем передачи каждого из них в сеть отдельно. Кроме того, при передаче изображения в сеть VGG нам нужна форма изображения фиксированного размера (224 * 224), и для достижения этого мы либо деформируем, либо обрезаем изображение, SPP снимает это ограничение, используя слой объединения пространственной пирамиды. В этом разделе мы рассмотрим эти две вещи.

слой пула пространственной пирамиды

Это не относится к обнаружению объектов, но помогает в целом обучать любую нейронную сеть. Каждая CNN принимает изображение фиксированного размера, потому что конечные уровни FC ожидают ввода одинакового размера. это можно понять, посмотрев на следующий пример

Скажем, для входного размера 224 размера изображения, conv5 (последний сверточный слой) имеет карту функций 13 * 13, а для другого входного размера 180 размер слоя conv5 теперь составляет 10 * 10. Если вы примените простое объединение 2 * 2, размер вывода будет 7 * 7 и 5 * 5 для размера ввода 224 и 180 соответственно. преобразование этого приведет к преобразованию сети, и в итоге получится слой размером 49 * 256 (256 карт объектов) и слой размером 25 * 256. Матрица весов, прикрепленная к слою FC, не может работать с этим, поскольку ожидает фиксированный вектор признаков. Таким образом, нам на помощь приходит слой SPP, мы используем l-уровень пирамидного пула.

Предположим, что размер карты функций равен * a, а уровень пирамиды - n * n. Шаг - пол (a / n), размер окна - ceil (a / n). для уровня пирамиды 3 у нас есть ячейки 3x3, 2x2, 1x1. На диаграмме ниже показаны дальнейшие вычисления.

Для целей вычислений они меняли размер только после каждой эпохи. Хотя SPP хорош, сейчас они устарели, и их позиции занимают средние глобальные уровни пула.

SPP-Net для обнаружения объектов

Поскольку извлечение признаков является основным узким местом при тестировании, в SPP-Net авторы применяют сеть CNN ко всему изображению и извлекают карту признаков (conv5) для входного размера 416x416 (они фактически использовали 5 масштабов при обучении сети. ) размер карты функций в conv5 равен 26 * 26 (с подвыборкой по 16).

Далее мы сгенерируем ~ 2000 предложений с помощью выборочного поиска. Для каждого предложения нам нужно извлечь вектор признаков фиксированной длины из карты признаков. Применяется это следующим образом.

Теперь, когда каждое предложение получает вектор признаков фиксированной длины, мы можем обучать классификаторы SVM, используя те же методы, что и в R-CNN.

Полученные результаты

Используя ZF-Net с SPP, они достигли 59,2% MAP по набору данных VOC. при многомасштабном уровне ПДП достигнуто 63,1%.
Вывод в сети SPP в единичном масштабе занимает 0,053 секунды по сравнению с 14,37 секунды по R-CNN. По шкале 5 это занимает 0,29 секунды, что в 49 раз быстрее.

Быстрый R-CNN

В этом документе были представлены прорывные результаты и установлены стандарты для последующего подхода.

Основные отличия Fast R-CNN от SPP-Net:

Удалили классификаторы SVM и присоединили к сети уровень регрессии и классификации. Таким образом, превращая его в одноэтапную сеть обучения и вывода
Удалите слой объединения SPP и соединили его с уровнем объединения ROI.
Используйте VGGNet в качестве бэкэнда, а не ZFNet, используемый SPP-Net.
Создавайте новые функции потерь, которые менее чувствительны к выбросам.

Быстрая сеть R-CNN работает следующим образом

Сеть обрабатывает все изображение для создания сверточной карты признаков. Затем для каждого предложения объекта слой объединения ROI извлекает вектор признаков фиксированной длины, который, наконец, передается на последующие уровни FC.
Слои FC разветвляются на два выходных уровня, один из которых оценивает вероятность softmax для классов объектов K + 1, а другой уровень создает уточненные положения ограничивающего прямоугольника.
2000 предложений конкретного изображения не передаются через сеть, как в R-CNN. Вместо этого изображение передается только один раз, а вычисленные характеристики совместно используются в ~ 2000 предложениях, как это делается в SPP Net.
Кроме того, уровень объединения ROI выполняет максимальное объединение в каждом подокне приблизительного размера h / H X w / W. H и W - гиперпараметры. Это частный случай слоя SPP с одним уровнем пирамиды.
Выходные данные двух смежных выходных слоев используются для расчета потерь при выполнении нескольких задач для каждой помеченной ROI для совместного обучения классификации и регрессии ограничивающей рамки.
Они использовали потерю L1 для регрессии ограничивающего прямоугольника в отличие от потерь L2 в R-CNN и SPP-Net, которые более чувствительны к выбросам.

Пулы рентабельности инвестиций

Также важно понимать, что он используется как в Faster R-CNN, так и в Mask R-CNN.

Проблема: поскольку объекты имеют разные размеры, слой объединения необходимо применять к разным размерам карт объектов. Предположим, что на приведенной выше диаграмме местоположение объекта [64, 64, 192, 192] на изображении равно [4, 4, 12, 12] на карте функций. местоположение объекта [128, 128, 384, 400] на изображении - [8, 8, 24, 25] на карте объектов. Теперь оба слоя объединения следует применить к обоим [4, 4, 12, 12] и [4, 4, 16, 18] и извлечь вектор признаков фиксированной длины.

Здесь вам на помощь приходит уровень пула RoI. Ниже приведена схема того, как это работает.

Функции потерь

Сеть Fast R-CNN имеет две одноуровневые сети, как обсуждалось выше, уровень классификации выводит дискретные оценки вероятности, а уровень регрессии выводит смещения значений x, y, w, h объекта. Для классификации мы можем использовать кросс-энтропийную потерю. для регрессии они используют плавную потерю L1.

Обучение

При обучении Fast R-CNN использует размер пакета 2, поскольку для размера пакета 2 у нас есть ~ 2000 x 2 = 4000 ящиков, и большинство из них не будут содержать объект, при обучении этой сети будет крайний дисбаланс классов. Для этого мы случайным образом отбираем 64+ бокса и 64-я бокса из ~ 4000 боксов и вычисляем потери только для этих боксов. Если у нас будет меньше положительных ящиков, мы добавим отрицательные ячейки. Всего у нас будет 128 ящиков на каждую итерацию. Такой же подход используется и в Faster R-CNN.

Кодировщик

Предложение считается находящимся на переднем плане, если оно имеет значение iou ›0,5 с любым ограничивающим прямоугольником, мы соответственно назначим класс предложению. предложения, содержащие [0,1, 0,5), считаются отрицательными. Остальные все предложения игнорируются

Полученные результаты

Обучение в 9 раз быстрее, чем R-CNN. В то время как быстрый вывод R-CNN в 213 раз быстрее, чем R-CNN. Аналогично с использованием VGG16 Fast R-CNN в 3 раза быстрее во время обучения и в 10 раз быстрее во время вывода по сравнению с SPP Net.
MAP по набору данных VOC-2007–12 достигает 71,8%. На COCO Pascal MAP составляет 35,9. Новый MAP в стиле кокоса, который в среднем превышает пороговые значения IoU, составляет 19,7% в наборе данных кокоса.

Быстрее R-CNN

Этот подход по-прежнему остается лучшим выбором для большинства исследователей и дает невероятные результаты. Алгоритм превзошел все предыдущие результаты как по точности, так и по скорости. Faster R-CNN также разработал новые методы, которые стали золотыми стандартами для всех будущих фреймворков. Давайте подробно рассмотрим эти методы.

Изменения в Fast R-CNN

Удален выборочный поиск и добавлена глубокая нейронная сеть для генерации предложений (сеть RPN)
Введены якорные ящики

Это два основных изменения, внесенных Faster R-CNN. Отсюда якорные коробки стали очень распространенными для всех каркасов. Сеть RPN может работать как детектор одиночных объектов или генерировать предложения для сети Fast R-CNN. Одно можно сказать наверняка: мы полностью удалили традиционные методы компьютерного зрения и создали полноценную глубокую нейронную сеть, которая обучается от начала до конца.

Как работает РПН?

Возьмите входное изображение 800x800 и отправьте его в сеть. Для сети VGG после коэффициента субдискретизации 16 на выходе будет [512, 50, 50]. На этой карте функций применяется сеть RPN, которая генерирует (50 * 50 * 9) ящиков регрессионных и классификационных оценок. Таким образом, вывод регрессии составляет 50 * 50 * 9 * 4 (x, y, w, h), а вывод классификации - 50 * 50 * 9 * 2 (присутствует объект или нет). Здесь 9 означает количество якорных ящиков в каждом месте. Ниже приведена процедура создания якорных ящиков на изображении. (Примечание: с небольшими изменениями это то, как якорные блоки применяются практически ко всем фреймворкам)

Якорные ящики

В каждом месте у нас есть 9 якорных ящиков, и у них разные масштабы и соотношения сторон. Следующие определены

anchors_boxes_per_location = 9
scales = [8, 16, 32]
ratios = [0.5, 1, 2]
ctr_x, ctr_y = 16/2, 16/2 [at (1,1) location)

На карте объектов местоположение 1,1 отображается в поле [0, 0, 16, 16] на изображении. у него центр в 8, 8. Теперь нам нужно нарисовать 9 якорных ящиков, используя указанные выше масштабы и соотношения. Посмотрите на все центры изображения

anchor_base = np.zeros((len(ratios) * len(scales), 4), dtype=np.float32)
print(anchor_base)
#Out:
# array([[0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.]], dtype=float32)
for i in range(len(ratios)):
 for j in range(len(anchor_scales)):
 h = sub_sample * anchor_scales[j] * np.sqrt(ratios[i])
 w = sub_sample * anchor_scales[j] * np.sqrt(1./ ratios[i])
 index = i * len(anchor_scales) + j
 anchor_base[index, 0] = ctr_y - h / 2.
 anchor_base[index, 1] = ctr_x - w / 2.
 anchor_base[index, 2] = ctr_y + h / 2.
 anchor_base[index, 3] = ctr_x + w / 2.
#Out:
# array([[ -37.254833, -82.50967 , 53.254833, 98.50967 ],
# [ -82.50967 , -173.01933 , 98.50967 , 189.01933 ],
# [-173.01933 , -354.03867 , 189.01933 , 370.03867 ],
# [ -56. , -56. , 72. , 72. ],
# [-120. , -120. , 136. , 136. ],
# [-248. , -248. , 264. , 264. ],
# [ -82.50967 , -37.254833, 98.50967 , 53.254833],
# [-173.01933 , -82.50967 , 189.01933 , 98.50967 ],
# [-354.03867 , -173.01933 , 370.03867 , 189.01933 ]],
# dtype=float32)

Это для одного места, теперь нам нужно подать заявку на все центры привязки. так как центров якоря 50 * 50, и в каждом по 9 якорей. Всего получаем 22500 якорей.

fe_size = 50
anchors = np.zeros((fe_size * fe_size * 9), 4)
index = 0
for c in ctr:
 ctr_y, ctr_x = c
 for i in range(len(ratios)):
 for j in range(len(anchor_scales)):
 h = sub_sample * anchor_scales[j] * np.sqrt(ratios[i])
 w = sub_sample * anchor_scales[j] * np.sqrt(1./ ratios[i])
 anchors[index, 0] = ctr_y - h / 2.
 anchors[index, 1] = ctr_x - w / 2.
 anchors[index, 2] = ctr_y + h / 2.
 anchors[index, 3] = ctr_x + w / 2.
 index += 1
print(anchors.shape)
#Out: [22500, 4]

Посмотрите на якоря (400, 400) на изображении

Таким образом, RPN создает предложения объектов по каждому блоку привязки вместе с их оценкой объектности. Якорному блоку присваивается + ve, если он имеет max_iou с наземным объектом истинности или iou больше 0,7. Якорному окну присваивается отрицательное значение, если оно имеет значение iou ‹0,4. Все якорные блоки с iou [0,4, 0,7] игнорируются. Якорные блоки, выходящие за пределы изображения, также игнорируются.
Опять же, поскольку подавляющее большинство из них будут иметь отрицательные выборки, мы будем использовать ту же стратегию Fast R-CNN для выборки 128 + ve выборок и 128-ти выборок (всего 256) для размера пакета 2 для обучения.
плавные потери L1 и перекрестные потери энтропии могут использоваться для регрессии и классификации. Выходы регрессии смещены с местоположениями якорных ящиков с использованием следующих формул

t_{x} = (x - x_{a})/w_{a}
t_{y} = (y - y_{a})/h_{a}
t_{w} = log(w/ w_a)
t_{h} = log(h/ h_a)

x, y, w, h - координаты центра наземного блока истинности, ширина и высота. x_a, y_a, h_a и w_a, а также центральные координаты, ширина и высота якорных боксов.

После генерации выходных данных RPN нам необходимо обработать их перед отправкой на уровень пула RoI (также известный как быстрая сеть R-CNN). Как сообщает Faster R_CNN, предложения RPN сильно пересекаются друг с другом. Чтобы уменьшить избыточность, мы применяем не максимальное подавление (NMS) для регионов предложения на основе их оценок cls. Мы фиксируем порог IoU для NMS на 0,7, что оставляет нам около 2000 регионов предложения на изображение. После исследования абляции авторы показывают, что NMS не вредит предельной точности обнаружения, но существенно сокращает количество предложений. После NMS мы используем для обнаружения первые N ранжированных регионов предложения. Далее мы обучаем Fast R-CNN, используя 2000 предложений RPN. Во время тестирования они оценивают только 300 предложений, они протестировали это с разными числами и получили это.

nms_thresh = 0.7
n_train_pre_nms = 12000
n_train_post_nms = 2000
n_test_pre_nms = 6000
n_test_post_nms = 300
min_size = 16

После создания ~ 2000 предложений они преобразуются с использованием следующих формул.

x = (w_{a} * ctr_x_{p}) + ctr_x_{a}
y = (h_{a} * ctr_x_{p}) + ctr_x_{a}
h = np.exp(h_{p}) * h_{a}
w = np.exp(w_{p}) * w_{a}
and later convert to y1, x1, y2, x2 format

Теперь эти 2000 предложений аналогичны предложениям, генерируемым выборочным поиском в Fast R-CNN. Таким образом, остальная часть процесса аналогична Fast R-CNN.

Полученные результаты

Логический вывод со скоростью 5 кадров в секунду на графическом процессоре
Используя бэкэнд VGG, с предварительным обучением на ImageNet и COCO, на VOC Faster RCNN достиг 73,2% mAP.
В наборе данных COCO Faster R-CNN достиг 21,9 МПа (кокосовый тип).

Сети функциональных пирамид

В этой строке исследователи обнаружили две проблемы с Faster R-CNN. Во-первых, он не может обнаруживать мелкие объекты, дисбаланс второго класса не сфокусирован должным образом (случайная выборка 256 выборок и расчет потерь не является правильным способом). Таким образом, исследователи представили две новые концепции.

Сети Feature Pyramid (FPN)
Focal Loss (Для проблем с экстремальным дисбалансом классов)

Мы кратко обсудим эти две техники здесь.

Сети Feature Pyramid

Если вы посмотрите на более быстрый RCNN, он в основном не может улавливать мелкие объекты на изображении. Это в значительной степени решается в задачах COCO и ILSVRC с использованием пирамид изображений большинством команд-победителей. Ниже приведена простая пирамида изображений, вы масштабируете изображение до разных размеров и отправляете его в сеть. После того, как обнаружения обнаруживаются на каждом масштабе, все прогнозы объединяются с использованием разных методов. Хотя этот метод работал, логический вывод - дорогостоящий процесс, поскольку каждое изображение должно вычисляться в различных масштабах независимо.

Глубокая ConvNet вычисляет иерархию объектов слой за слоем, а со слоями подвыборки иерархия объектов имеет характерную многомасштабную пирамидальную форму. Эта внутрисетевая иерархия объектов создает карты объектов с различным пространственным разрешением. Сначала давайте посмотрим, как работает FPN, а позже мы перейдем к части интуиции.

Сначала возьмем стандартную архитектуру resnet (Ex ResNet50). В Faster R-CNN, обсуждавшемся выше, мы рассмотрели только карты характеристик с коэффициентом субдискретизации 16, которые были взяты для вычисления предложений по регионам, а затем для передачи выходных данных RPN в Fast RCNN. Здесь это делается следующим образом:

Проблема с чрезмерной подвыборкой в том, что это приведет к плохой локализации. Если мы хотим использовать функции из более ранних слоев (скажем, подвыборки 8), семантика объекта улавливается не очень четко. Итак, мы должны взять лучшее из обоих миров. Благодаря этой интуитивной функции пирамидальные сети или FPN сначала разрабатываются на Faster RCNN. Последние слои уменьшают размер канала (количество карт функций), повышают дискретизацию и добавляются к выходным данным предыдущего слоя. Поскольку повышающая дискретизация выполняется с использованием билинейной интерполяции, они добавили еще один сверточный слой в этот вывод, чтобы исключить эффект наложения спектров при повышающей дискретизации. Мы проигнорировали p1 из-за вычислительной сложности (он генерирует (400 * 400 * 3 = 480 тыс. Предложений для одной карты функций p1).
Якорные блоки создаются на каждой карте функций отдельно. Поскольку масштабирование выполняется FPN, в каждом месте мы берем якоря с 3-мя соотношением сторон [1: 2, 2: 1, 1: 1]. В общей сложности мы получаем 9 якорей в каждом месте над масштабом карты объектов.

ФПН для РПН

В Faster RCNN сверточный слой 3x3 скользит по карте признаков и извлекает признаки, которые затем оцениваются двумя одноуровневыми сетями, одна для регрессии (1x1 conv), а другая - для классификации (1x1 conv). Теперь, реализуя FPN, мы строим ту же сеть, но здесь мы перемещаем сеть на каждой карте функций.

FPN для Fast R-CNN

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

Полученные результаты:

некоторые исследования абляции показывают, что при использовании FPN средняя точность (AR ^ (1k)) улучшилась на 8,0 балла по сравнению с RPN с одной шкалой. Это также увеличило производительность с большой маржой на 12,9 пункта.
боковые соединения улучшили AP на 10 пунктов.
COCO AP составляет 33,9, а VOC AP @ 5 - 56,9. На небольших объектах AP в стиле кокоса улучшился с 9,6% до 17,8%.
Используя ResNet-101 в качестве бэкэнда, VOC AP составил 59,1%, а MAP в стиле кокоса - 36,2%.
Вывод для каждого изображения занимает 176 мс при использовании resnet101 в качестве бэкэнда.

RetinaNet (комбинированные потери фокуса и FPN)

Все методы, которые мы видели для обнаружения объектов, до тех пор, пока они не являются двухэтапными: RPN генерирует предложения объектов, а затем Fast RCNN классифицирует и регрессирует поверх этих предсказанных предложений объектов. Уместный вопрос: можем ли мы строить одноступенчатые детекторы?

Во-вторых, при оценке якорных ящиков от 1⁰⁴ до 1⁰⁵ в сети Faster RCNN (FPN) большинство ящиков не содержат объектов, что приводит к крайнему дисбалансу классов. Чтобы уравновесить классовый дисбаланс, мы отбираем 256 предложений из каждой мини-партии (128 + ve и 128-ve). Однако это не роботизированный подход, и авторы этой статьи предложили функцию потерь, называемую Focal loss, которая пытается эффективно устранить дисбаланс классов.

Одноступенчатый детектор (FPN)

Как показано на диаграмме ниже, P3, P4, P5, P6, P7 - это выходы внутренней сети. Мы не используем P1 и P2 по вычислительным причинам.

Каждый выходной сигнал затем передается на уровень регрессии и уровень классификации, которые представляют собой набор сверточных слоев (4) вместе с выходным слоем. Все сверточные слои имеют 256 входных каналов и 256 выходных каналов и применяют скользящее окно 3x3. Релу находится между всеми слоями. Выходные данные уровня регрессии имеют линейный слой, а уровень классификации имеет функцию активации сигмоида (количество классов как выход) или softmax (количество классов +1) в конце

Якорные ящики сконструированы так же, как указано в разделе ФПН, с некоторыми изменениями. Шаги равны [8, 16, 32, 64, 128] для [p3, p4, p5, p6, p7] соответственно. Хотя FPN заботится о масштабах, в документе сообщается о лучших результатах с использованием якорей разных масштабов на каждой карте функций. Итак, у нас есть 9 якорей в каждом месте карты функций, всего 45 якорей по всем масштабам. Они использовали якорные блоки размером [²⁰, 2 ^ (1/3), 2 ^ (2/3)] и соотношением сторон [0,5, 1, 2]. Код sudo следующий

aspect_ratios = [0.5, 1, 2]
kmin, kmax = 3, 7 #feature scales
scales_per_fe = 3 
anchor_scale = 4 
num_aspect_ratios = len(aspect_ratios)
num=0
for lvl in range(k_min, k_max+1):
 stride = 2. ** lvl 
 for fe in range(scales_per_fe):
 fe_scale = 2**(fe/float(scales_per_fe))
 for idx in range(num_aspect_ratios):
 anchor_sizes = (stride* fe_scale * anchor_scale,)
 anchor_aspect_ratios=(aspect_ratios[idx],)
 num+1=1
 print(anchor_sizes, anchor_aspect_ratios)
#out
1 (32.0,) (0.5,)
2 (32.0,) (1,)
3 (32.0,) (2,)
4 (40.317,) (0.5,)
5 (40.317,) (1,)
6 (40.317,) (2,)
---
43 (812.75,) (0.5,)
44 (812.75,) (1,)
45 (812.75,) (2,)

кодировки аналогичны более быстрому RCNN, если блок привязки имеет iou ›0,5 с наземной истиной, это + ve,‹ 0,4 это -ve, а все остальные игнорируются. Каждой привязке назначается не более одной привязки.
Для размера ввода 640x640 мы получаем 8525 ((80 * 80) + (40 * 40) + (20 * 20) + (10 * 10) + (5 * 5)) ячеек. Поскольку в каждом месте есть 9 якорей, мы получаем в общей сложности 76725 якорей (8525x9).

Функция потерь

В регрессии используются плавные потери L1, которые менее чувствительны к выбросам. Это та же потеря, которая до сих пор использовалась во всех фреймворках.

Потеря классификации называется фокальной потерей, которая представляет собой измененную версию кросс-энтропийной потери, и в этой статье об этом много говорится.

Фокусные потери - это изменение формы потери кросс-энтропии таким образом, что она снижает вес потерь, присваиваемых хорошо классифицированным примерам. Новая функция потери фокуса фокусирует обучение на небольшом наборе сложных примеров и предотвращает перегрузку детектора огромным количеством легких негативов во время обучения.

Давайте посмотрим, как устроены эти фокусные потери. Сначала мы рассмотрим двоичную кросс-энтропийную потерю для классификации отдельных объектов.

Перекрестная потеря энтропии:

Потеря очага:

где p_ {t} равно p, если y = 1, и 1-p в противном случае. Давайте внимательно посмотрим на уравнение фокальных потерь. Здесь альфа называется параметром балансировки, а гамма - параметром фокусировки.
Параметр балансировки обычно является обратным количеству экземпляров определенного класса. Это придает меньший вес классам с большим количеством образцов. Здесь к отрицательным предложениям.
Параметр фокусировки добавляет меньше веса хорошо классифицированным примерам и больше весит трудно классифицированным / пропущенным примерам. Давайте проверим, как это достигается, используя 4 сценария. Я уже объяснял это в другом своем блоге и для полноты картины.

Сценарий-1: Легко правильно классифицированный пример

Допустим, у нас есть легко классифицируемый объект переднего плана с p = 0,9. Теперь обычная потеря кросс-энтропии для этого примера равна

CE (передний план) = -log (0,9) = 0,1053

Теперь рассмотрим легко классифицируемый фоновый объект с p = 0,1. Теперь обычная потеря кросс-энтропии для этого примера снова такая же.

CE (фон) = -log (1–0,1) = 0,1053

Теперь рассмотрим потерю фокуса для обоих вышеупомянутых случаев. Мы будем использовать альфа = 0,25 и гамма = 2.

FL (передний план) = -1 x 0,25 x (1–0,9) ** 2 log (0,9) = 0,00026

FL (фон) = -1 x 0,25 x (1– (1–0,1)) ** 2 log (1–0,1) = 0,00026.

Сценарий 2: неверно классифицированный пример

Допустим, у нас есть неверно классифицированный объект переднего плана с p = 0,1. Теперь обычная потеря кросс-энтропии для этого примера равна

CE (передний план) = -log (0,1) = 2,3025

Теперь рассмотрим неправильно классифицированный фоновый объект с p = 0,9. Теперь обычная потеря кросс-энтропии для этого примера снова такая же.

CE (фон) = -log (1–0,9) = 2,3025

Теперь рассмотрим потерю фокуса для обоих вышеупомянутых случаев. Мы будем использовать альфа = 0,25 и гамма = 2.

FL (передний план) = -1 x 0,25 x (1–0,1) ** 2 log (0,1) = 0,4667

FL (фон) = -1 x 0,25 x (1– (1–0,9)) ** 2 log (1–0,9) = 0,4667

Сценарий 3: очень легко классифицируемый пример

Скажем, у нас есть легко классифицируемый объект переднего плана с p = 0,99. Теперь обычная потеря кросс-энтропии для этого примера равна

CE (передний план) = -log (0,99) = 0,01

Теперь рассмотрим легко классифицируемый фоновый объект с p = 0,01. Теперь обычная потеря кросс-энтропии для этого примера снова такая же.

CE (фон) = -log (1–0,01) = 0,1053

Теперь рассмотрим потерю фокуса для обоих вышеупомянутых случаев. Мы будем использовать альфа = 0,25 и гамма = 2.

FL (передний план) = -1 x 0,25 x (1–0,99) ** 2 log (0,99) = 2,5 * 10 ^ (- 7)

FL (фон) = -1 x 0,25 x (1– (1–0,01)) ** 2 log (1–0,01) = 2,5 * 10 ^ (- 7)

Заключение:

сценарий-1: 0,1 / 0,00026 = в 384 раза меньшее число

сценарий-2: 2,3 / 0,4667 = в 5 раз меньшее число

сценарий-3: 0,01 / 0,00000025 = число в 40 000 раз меньше.

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

Вывод на RetinaNet

Это основная интуиция при проектировании Focal loss. Авторы протестировали различные значения альфа и гаммы и окончательно установили с указанными выше значениями.

После установления порогового значения достоверности детектора 0,05 было получено 1000 предложений по каждой шкале признаков. Лучшие прогнозы со всех уровней объединяются, и применяется не максимальное подавление с порогом 0,5 для получения окончательных обнаружений.

Примечание: будьте осторожны при инициализации сети со случайными весами. Авторы предложили использовать (-1) x math.log ((1–0.01) /0.01) для смещения последнего слоя. Если этого не сделать, мы получим огромное значение потерь на первой итерации и переполнение градиентов, что в конечном итоге приведет к NaN.

Полученные результаты

По набору данных COCO, Retinanet достиг MAP в стиле кокоса 40,8 и MAP в стиле VOC 61,1 MAP. AP в стиле кокоса для мелких объектов составляет 24,1, для средних объектов - 44,2 и для крупных объектов - 51,2.
Используя размер входных данных 600x600 и resnet101 в качестве бэкэнда, логический вывод занимает 122 мс для каждого изображения.

Йоло (смотришь только один раз)

YOLO - важная структура, которая позволила повысить скорость и точность задач обнаружения объектов. Йоло развивался с течением времени и к настоящему времени опубликовал 3 статьи. Хотя большинство идей аналогичны тем, которые мы обсуждали выше, YOLO предлагает определенные улучшения, которые особенно направлены на более быстрое время обработки.

На сегодняшний день у Yolo есть три статьи, Yolo1, yolo2, Yolo3, которые показали улучшения с точки зрения точности.
Yolo1 публикуется независимо, и, насколько мне известно, это первая статья, в которой говорится об одноэтапном обнаружении. RetinaNet берет идеи от Yolo и SSD.

Ячейки сетки

Сначала мы делим изображение на сетку ячеек. Скажем, это 7x7. Теперь объекты наземной истины, центры которых находятся в соответствующих ячейках сетки, оказываются положительными ячейками.

Каждая ячейка предсказывает 2 ограничивающих прямоугольника, а каждый ограничивающий прямоугольник состоит из 5 прогнозов: x, y, w, h и достоверность. Координаты (x, y) представляют центр прямоугольника относительно границ ячейки сетки. Ширина и высота прогнозируются относительно всего изображения. Наконец, доверительный прогноз представляет собой долговую расписку между предсказанным блоком и любым наземным блоком истинности. Таким образом, для VOC с 20 классами выход будет ((4 + 1) x2 + 20) = 30. Если размер сетки 7x7, у нас будет 7x7x30 выходов.

def normal_to_yolo_format(bbox, anchor, img_size, grid_size):
 y, x, h, w = bbox #bounding box
 y1, x1, y2, x2 = anchor # supporting cell
 size_h = img_size[0]/ grid_size[0] # height of the cell
 size_w = img_size[1]/grid_size[1] # width of the cell
 new_x = (x - x1)/size_w # center_x wrt to cell
 new_y = (y - y1)/size_h #center_y wrt to cell
 new_h = h/img_size[0] # height of the object normalized with the heigth of the image
 new_w = w/img_size[1] # width of the object normalized with the width of the image
 return [new_y, new_x, new_h, new_w]

Кодирование ограничивающих рамок

For each cell,
 For each ground_truth_bbox:
 check if the cell contains bbox center or not,
 if yes:
 encode the box with respective values of bbox, label and binary encoding of object present or not[1 in this case].

Проблема с кодировками:

Что будет, если ячейка сетки будет содержать два центра объектов? Вы можете выбрать один из объектов случайным образом или увеличить размер сетки до гораздо большего числа, например 16x16. Это в значительной степени решено в Yolov2, и мы рассмотрим der.

Сеть

Yolo использует другую сеть под названием DarkNet, созданную автором дома, в отличие от других фреймворков, использующих стандартные хорошо выполненные архитектуры ImageNet.

Функции потерь.

Yolo содержит три функции потерь.

Ошибка координат
Оценка объективности
Ошибка классификации.

Ошибка координат и ошибка классификации оцениваются только в том случае, если оценка объектности составляет ›0,5, что представлено как 1 ^ obj. Убыток рассчитывается индивидуально для каждой ячейки сетки и позже все суммируется. w и h имеют квадратные корни для решения следующей проблемы

Небольшому объекту, предсказывающему неверно, следует придавать больший вес, чем большому объекту, предсказывающему неверно.

\ lambda_coord и \ lambda_noobj равны 5 и 0,5 соответственно.

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

Обучение

DarkNet - это первая предварительная подготовка к классификации на Imagenet. Точность первой пятерки составила 88%. Поскольку для обнаружения требуется мелкозернистая информация, они использовали изображения размером 448x448, а не 224x224. Они обнаружили, что ошибки высоки в начальные эпохи, и подумали, что это могло быть из-за изменения размеров изображений. поэтому они снова обучили сеть на изображении, используя 448x448 для первых нескольких эпох, а затем перешли к наборам данных вокала.
Позже сеть обучается на наборе данных VOC-2007 и 2012 для 135 эпох. На протяжении всего обучения они использовали batch_size 64, импульс 0,9 и спад 0,0005. График скорости обучения следующий. В первые эпохи они медленно повышали скорость обучения с 10 ^ -3 до 10 ^ -2. Продолжение тренировки с 10 ^ -2 для 75 эпох, затем 10 ^ -3 для 30 эпох и, наконец, 10 ^ -4 для 30 эпох.
Чтобы избежать чрезмерной подгонки, они использовали отсев и обширное увеличение данных. В нашем случае мы также использовали пакетную нормализацию.
Для увеличения данных они использовали случайное масштабирование и переводы до 20% от исходного размера изображения. Они также случайным образом регулируют экспозицию и насыщенность изображения с коэффициентом до 1,5 в цветовом пространстве HSV.

Полученные результаты

Йоло очень быстр. Работает со скоростью 45 кадров в секунду
YOLO с использованием DarkNet достигает MAP 63,4 при 45 кадрах в секунду. mAP намного меньше по сравнению с более быстрым R-CNN с использованием VGG-16 (73,2), но скорость более быстрого R-CNN составляет 7 кадров в секунду. Платформа Fast R-CNN обеспечивает MAP 71,8% при 0,5 FPS (кадров в секунду).
Yolo налагает строгие пространственные ограничения на предсказания ограничивающего прямоугольника, поскольку каждая ячейка сетки предсказывает только два прямоугольника и может иметь только один класс. Это пространственное ограничение ограничивает количество ближайших объектов, которые наша модель может предсказать. Например, Йоло будет очень сложно предсказать стаю животных (птиц).
Поскольку модель предсказывает ограничивающие прямоугольники на основе данных, ей трудно обобщить объекты с новыми или необычными пропорциями и конфигурациями.
Yolo лучше делает меньше ошибок локализации, поскольку он смотрит на все изображение, чтобы предсказать объекты в отдельных ячейках. Таким образом, Yolo фиксирует и рассматривает глобальные особенности всего изображения для прогнозирования отдельных ячеек, чего нельзя сказать о Faster R-CNN. Обзор ошибок показал, что Fast R-CNN почти в 3 раза делает фоновые ошибки по сравнению с Yolo. Таким образом, для каждого ограничивающего прямоугольника, который предсказывает Fast R-CNN, он снова оценивается Yolo. Это улучшило MAP Fast R-CNN на 3,2% до 75%.

Ёлов2

В этой статье мы выделим модификации, которые они купили для Yolo.

При 67 FPS YOLOv2 получает 76,8 MAP на VOC 2007. При 40 FPS YOLOv2 получает 78,6 MAP, превосходя современные методы, такие как Faster R-CNN с ResNet и SSD, при этом работая значительно быстрее.
Yolo использует якорные блоки в каждой ячейке сетки. это позволит нам кодировать несколько блоков в одних и тех же ячейках сетки.
Масштаб и соотношение сторон для ограничивающих рамок для якорных рамок задаются с помощью набора данных. (Я напишу об этом отдельную статью, так как ее можно использовать и во всех других фреймворках). Установка лучших априорных значений и понимание набора данных имеют первостепенное значение и впервые рассматриваются только в статье Yolov2.
Размер сетки увеличен с 7x7 до 13x13. Это также должно происходить из набора данных. Если у вас очень маленькие объекты, мы можем увеличить их до 32x32 или 50x50 в зависимости от необходимости. Одна из предварительных проверок, которые нам необходимо сделать при рассмотрении размера сетки, заключается в следующем: ни одного якорного ящика не должно быть более одного ящика наземной истины.
В сети была представлена пакетная нормализация. Подобно сети в сети, они использовали глобальный средний пул и свертки 1x1.
Кодирование x, y, w, h изменилось следующим образом. Это были те же уравнения, которые использовались в Yolov3. Это сделано потому, что прямое прогнозирование местоположения объектов на изображении приводит к нестабильности модели, и они также не ограничены.

Разномасштабное обучение. Вместо того, чтобы фиксировать размер входного изображения, мы меняем сеть каждые несколько итераций. Каждые 10 пакетов наша сеть случайным образом выбирает новый размер изображения. Поскольку наша модель сокращает выборки в 32 раза, мы берем из следующих кратных 32: {320, 352,…, 608}. Таким образом, наименьший вариант - 320 × 320, а наибольший - 608 × 608. Мы изменяем размер сети до этого измерения и продолжаем обучение.

Ёлов3

Бумага Yolov3 - это увлекательное чтение, и мы выделим здесь самые важные вещи.

Yolov3 достигает 33,4 IOU @ 0,5: 0,95 MAP и 57,9 IOU@0,5 MAP. Автор пытается понять, почему мы переключили наши метрики и поддерживаем [email protected] (стиль VOC). Используя mAP в стиле VOC, Yolov3 очень надежен
Yolov3 заменяет darknet19 на darknet53 и вводит остаточные блоки. Он также вводит FPN. Сети выглядят так, как показано ниже.

Функция потерь аналогична Yolov2 и Yolov1, за исключением того, что она использует бинарную кросс-энтропию. В моих экспериментах это не сработало, и я использовал потерю MSE, разделенную на количество положительных ограничивающих прямоугольников.
Кодирование происходит следующим образом. Поле gt прикреплено к якорю, у которого есть max_iou. В качестве привязок рассматриваются только привязки ячейки, содержащие центр gt_box.
Так как Yolov3 использует 3 шкалы: 52x52, 26x26 и 13x13. Ограничительные рамки кодируются индивидуально на каждом масштабе. потери рассчитываются на каждом слое индивидуально, а затем суммируются.

SSD - Детектор одиночных выстрелов

Это последняя структура, которую мы будем обсуждать в этом сообщении в блоге, почти все идеи в этой статье уже обсуждались выше.
Выпущенный после YOLO и Faster RCNN, этот документ достигает 74,3 MAP при 59 кадрах в секунду для изображений входного размера 300x300. Мы называем эту сеть SSD300. Аналогичным образом SSD512 достигает 76,9% MAP, превосходя результаты Faster R-CNN.

Сеть

Сама газета сравнивает это сетевое с YOLO. Он использует бэкэнд VGG и извлекает функции из нескольких масштабов. Обратите внимание, что он не использует никаких боковых соединений, таких как Yolov3 и FPN.

Конструкция якорной коробки

Поскольку карты функций из разных слоев уже фиксируют масштабы, SSD использует только один масштаб для каждого слоя, однако масштаб определяется по формуле sk = smin + (smax - smin) / (m-1) * (k-1), где smin составляет 0,2, а smax - 0,9.
Используются соотношения сторон [1, 2, 3, 1/2, 1/3]. w и h для каждого блока определяются с использованием sk * a ^ (1/2) и sk / a ^ (1/2). Они также добавили якорь размером (sk * sk + 1) ^ (1/2), всего до 6 якорных ящиков на каждое место.
Как показано на диаграмме, conv4_3 (38x38), conv7 (fc7) (19x19), conv8_2 (10x10), conv9_2 (5x5), conv10_2 (3x3) и conv11_2 (1x1). Авторы предложили использовать привязки [4, 6, 6, 6, 4, 4] на каждом масштабе признаков. Общее количество якорей = (38x38x4) + (19x19x6) + (10x10x6) + (5x5x6) + (3x3x4) + (1x1x4) = (8732 якоря)

Кодирование

SSD использует перекрытие Jaccard, и все якорные блоки, которые перекрываются ›0,5, считаются положительными.

Функции потерь

Для уверенности используется кросс-энтропийная потеря. Для loc используется плавная потеря L1. В отличие от Faster R-CNN, чтобы устранить дисбаланс классов, они не просто случайным образом выбирали поля + ve и -ve. Они упорядочили оценку «объективности» в порядке убывания для отрицательных образцов и заняли верхние ящики. Таким образом, они получили соотношение выборок 3: 1 к положительным, что привело к более быстрой сходимости.

Это оно. Мы обсудили почти все современные документы в области обнаружения объектов. Есть так много других статей для улучшения mAP (Ex GroupNorm вместо BatchNorm), чтобы обсудить более быстрое обучение (Ex Use SGDR). Но пока мы должны положить этому конец.