YOLO или You Only Look Once это архитектура свёрточных нейронных сетей, которая используется для распознавания множественных объектов на изображении. В 2020, на фоне пандемии, задача детектирования объектов (object detection) на изображении стала как никогда актуальной. Эта статья даёт полное пошаговое руководство для тех, кто хочет научиться распознавать объекты с помощью YOLO на разных данных. Предполагается, что вы уже знаете, как делать распознавание объектов с помощью методов глубокого обучения и, в частности, вы знаете основы YOLO, так что давайте погрузимся в нашу задачу.

Я собираюсь работать с YOLOv3 одной из самых ходовых версий YOLO, которая включает в себя современную, удивительно точную и быструю систему обнаружения объектов в реальном времени. Новые версии, такие как YOLOv4, YOLOv5, могут достичь даже лучших результатов. Этот проект вы найдёте в моём репозитории на Github.

Рабочее окружение

Чтобы реализовать проект, я использовал Google Colab. Первые эксперименты с предварительной обработкой не были вычислительно дорогими, поэтому выполнялись на моём ноутбуке, но модель обучалась на GPU Google Colab.

Набор данных

Для начала, чтобы сделать детектор маски, нужны соответствующие данные. Кроме того, из-за природы YOLO нужны аннотированные данные с ограничивающими прямоугольниками. Один из вариантов создать собственный набор данных, либо собирая изображения из Интернета, либо фотографируя друзей, знакомых и аннотируя фотографии вручную с помощью определённых программ, таких как LabelImg.Однако оба варианта утомительные и трудоёмкие, особенно последний. Есть другой вариант, самый жизнеспособный для моей цели, работать с публичным набором данных.

Я выбрал Набор обнаружения маски на лице от Kaggle и загрузил его прямо в мой Google Drive. Посмотрите здесь, как это можно сделать. Скачанный набор данных это две папки:

• images, содержит 853 .png файла;

• annotations, содержит 853 соответствующих аннотации в формате XML.

После загрузки набора данных, чтобы тренировать нашу модель, нам нужно преобразовать файлы .xml в .txt, а если точнее, в формат YOLO. Пример:

<annotation>    <folder>images</folder>    <filename>maksssksksss0.png</filename>    <size>        <width>512</width>        <height>366</height>        <depth>3</depth>    </size>    <segmented>0</segmented>    <object>        <name>without_mask</name>        <pose>Unspecified</pose>        <truncated>0</truncated>        <occluded>0</occluded>        <difficult>0</difficult>        <bndbox>            <xmin>79</xmin>            <ymin>105</ymin>            <xmax>109</xmax>            <ymax>142</ymax>        </bndbox>    </object>    <object>        <name>with_mask</name>        <pose>Unspecified</pose>        <truncated>0</truncated>        <occluded>0</occluded>        <difficult>0</difficult>        <bndbox>            <xmin>185</xmin>            <ymin>100</ymin>            <xmax>226</xmax>            <ymax>144</ymax>        </bndbox>    </object>    <object>        <name>without_mask</name>        <pose>Unspecified</pose>        <truncated>0</truncated>        <occluded>0</occluded>        <difficult>0</difficult>        <bndbox>            <xmin>325</xmin>            <ymin>90</ymin>            <xmax>360</xmax>            <ymax>141</ymax>        </bndbox>    </object></annotation>

Предположим, что это аннотация изображения, содержащего только 3 ограничительных прямоугольника, это видно по количеству <object> ... </object> в XML.

Чтобы создать подходящий текстовый файл, нам нужно 5 типов данных из каждого XML-файла. Для каждого <object> ... </object> в XML-файле извлеките класс, то есть поле <name>...</name> и координаты ограничивающего прямоугольника 4 атрибута в <bndbox>...</bndbox>. Подходящий формат выглядит так:

<class_name> <x_center> <y_center> <width> <height>

Я написал скрипт, который извлекает 5 атрибутов каждого объекта в каждом XML-файле и создаёт соответствующие файлы TXT.Подробные комментарии о подходе к преобразованию вы найдёте в моём скрипте. К примеру, у Image1.jpg должен быть соответствующий Image1.txt, вот такой:

1 0.18359375 0.337431693989071 0.05859375 0.101092896174863390 0.4013671875 0.3333333333333333 0.080078125 0.120218579234972671 0.6689453125 0.3155737704918033 0.068359375 0.13934426229508196

Это точное преобразование вышеупомянутого файла .xml в подходящий текст.

Примечание: очень важно сгруппировать изображения и соответствующие TXT в одну папку.

Конечно, прежде чем приступить к обучению модели, мы должны быть абсолютно уверены, что преобразование было правильным, потому что хотим подать модели достоверные данные. Чтобы гарантировать соответствие, я написал скрипт, который берёт изображение и соответствующую ему текстовую аннотацию из заданной папки и отображает взятое изображение с ограничивающими прямоугольниками. Вот что получилось:

Пока всё хорошо, давайте продолжим.

Разделение данных

Чтобы обучить нашу модель и проверить её на этапе обучения, мы должны разделить данные на два набора набор обучения и набор тестирования. Пропорция составила 90 и 10 % соответственно. Поэтому я создал две новые папки и поместил 86 изображений с аннотациями в test_folder, а остальные 767 изображений в train_folder.

Клонирование фреймворка darknet

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

!git clone https://github.com/AlexeyAB/darknet

После этого нам нужно загрузить веса предварительно обученной модели, то есть применить трансферное обучение, а не обучать модель с нуля.

!wget https://pjreddie.com/media/files/darknet53.conv.74

darknet53.conv.74 основа сети YOLOv3, которая вначале обучается классификации на наборе данных ImageNet и играет роль экстрактора. Чтобы использовать её для распознавания, дополнительные веса сети YOLOv3 перед обучением инициализируются случайным образом. Но, конечно, на этапе обучения сеть получит надлежащие веса.

Последний шаг

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

1. face_mask.names: создайте содержащий классы задачи файл _.names.

В нашем случае исходный набор данных Kaggle имеет 3 категории: with_mask, without_mask и mask_weared_incorrect [с маской, без маски, маска надета неправильно].

Чтобы немного упростить задачу, я объединил две последние категории в одну. Итак, есть две категории, Good и Bad, на основании того, правильно ли кто-то носит свою маску:

1. Good.2. Bad.

2. face_mask.data: создайте файл _.data, который содержит релевантную информацию о нашей задаче, с ним будет работать программа:

classes = 2train = data/train.txtvalid  = data/test.txtnames = data/face_mask.namesbackup = backup/

Примечание: если папки резервного копирования нет, создайте её, потому что там будут сохраняться веса за каждую тысячу итераций. На самом деле это будут ваши контрольные точки на случай, если обучение неожиданно прервётся; если что, вы сможете продолжить тренировать модель.

3. face_mask.cfg: Этот конфигурационный файл должен быть адаптирован к нашей задаче, а именно нам нужно скопировать yolov3.cfg переименовать его в _.cfg и изменить код, как описано ниже:

• строку batch на batch=64;

• строку subdivisions на subdivisions=16. В случае проблемы с памятью увеличьте это значение до 32 или 64;

• входные размеры на стандартные: width=416, height=416;

• строку max_batches на (#classes * 2000), это даст 4000 итераций для нашей задачи.

Я начал с разрешения 416x416 и обучил свою модель на 4000 итераций, но, чтобы достичь большей точности, увеличил разрешение и продлил обучение ещё на 3000 итераций. Если у вас есть только одна категория, вы не должны тренировать свою модель только до 2000 итераций. Предполагается, что 4000 итераций это минимум.

• измените строку steps на 80% и 90% max_batches. В нашем случае 80/100 * 4000 = 3200, 90 / 100 * 4000 = 3600;

• нажмите Ctrl+F и найдите слово "yolo". Поиск приведёт прямо к yolo_layers, где вы измените количество классов (в нашем случае classes=2) и количество фильтров. Переменная filters это вторая переменная выше строки [yolo].

  Строка должна стать такой: filters=(classes + 5) * 3, в нашем случае это filters = (2 + 5) * 3 = 21. В файле .cfg есть 3 слоя yolo_layers, поэтому упомянутые выше изменения нужно выполнить трижды.

4. Файлы train.txt и test.txt: Эти два файла были включены в файл face_mask.data и указывают абсолютный путь каждого изображения к модели. Например, фрагмент моего файла train.txt выглядит так:

/content/gdrive/MyDrive/face_mask_detection/mask_yolo_train/maksssksksss734.png/content/gdrive/MyDrive/face_mask_detection/mask_yolo_train/maksssksksss735.png/content/gdrive/MyDrive/face_mask_detection/mask_yolo_train/maksssksksss736.png/content/gdrive/MyDrive/face_mask_detection/mask_yolo_train/maksssksksss737.png/content/gdrive/MyDrive/face_mask_detection/mask_yolo_train/maksssksksss738.png...

Как я уже говорил, файлы .png должны располагаться в одной папке с соответствующими текстовыми аннотациями.

Это означает, что проект структурирован так:

MyDrivedarknet      ...      backup      ...      cfg            face_mask.cfg      ...      data            face_mask.data            face_mask.names            train.txt            test.txtface_mask_detection      annotations       (contains original .xml files)      images            (contains the original .png images)      mask_yolo_test    (contains .png % .txt files for testing)      mask_yolo_train   (contains .png % .txt files for training)       show_bb.py       xml_to_yolo.py

Начало обучения

После компиляции модели нужно изменить права на папку darknet, вот так:

!chmod +x ./darknet

И начинаем тренировать модель, запустив такую команду:

!./darknet detector train data/face_mask.data cfg/face_mask.cfg backup/face_mask_last.weights -dont_show -i 0 -map

Прописываем флаг -map, чтобы в консоль выводились важные показатели, такие как average Loss, Precision, Recall, AveragePrecision (AP), meanAveragePrecsion (mAP) и т. д.

Однако индикатор mAP в консоли считается лучшей метрикой, чем Loss, поэтому обучайте модель до тех пор, пока mAP возрастает.

В зависимости от различных параметров обучение может занимать часы, это нормально. Мне понадобилось около 15 часов, но первые впечатления от модели я получил примерно после 7 часов, то есть 4000 итераций.

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

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

!./darknet detector test data/face_mask.data cfg/face_mask.cfg backup/face_mask_best.weights

Вы заметили, что мы использовали face_mask_best.weights, а не face_mask_final.weights? К счастью, наша модель сохраняет лучшие веса (mAP достиг 87,16 %) в папке резервного копирования на случай, если мы тренируем её на большем количестве эпох, чем следовало бы (что, возможно, приведёт к переобучению).

Изображения ниже взяты из Pexels, набора изображений высокого разрешения, и невооружённым глазом видно, что они существенно отличаются от тестового и тренировочного наборов данных и, таким образом, имеют другое распределение. Чтобы посмотреть, насколько модель способна к обобщению, я выбрал эти фото:

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

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

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

Я заметил, что относительно стоящего впереди человека модель не столь уверена (38 % в чёткой области) в сравнении с прогнозом для человека сразу за ним (100 % в размытой области). Это может быть связано с качеством обучающего набора данных, таким образом, модель, по-видимому, в определённой степени подвержена влиянию (по крайней мере она не является неточной).

Один последний тест

Конечно, большое преимущество Yolo её скорость. Поэтому я хочу показать вам, как она работает с видео:

!./darknet detector demo data/face_mask.data cfg/face_mask.cfg backup/face_mask_best.weights -dont_show vid1.mp4 -i 0 -out_filename res1.avi

Это был мой первый пошаговый туториал о том, как сделать собственный детектор с помощью YOLOv3 на пользовательском наборе данных. Надеюсь, он был вам полезен. А если хотите научиться создавать собственные нейронные сети и решать задачи с помощью глубокого обучения обратите внимание на курс Machine Learning и Deep Learning.

Узнайте, как прокачаться и в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

До появления YOLO большинство способов обнаружения объектов пытались адаптировать классификаторы для детекции. В YOLO же, обнаружение объектов было сформулировано как задача регрессии на пространственно разделенных ограничивающих рамок (bounding boxes) и связанных с ними вероятностей классов.

В данной статье мы узнаем о системе YOLO Object Detection и как реализовать подобную систему в Tensorflow 2.0

О YOLO:

Наша унифицированная архитектура чрезвычайно быстра. Базовая модель YOLO обрабатывает изображения в режиме реального времени со скоростью 45 кадров в секунду. Уменьшенная версия сети, Fast YOLO, обрабатывает аж 155 кадра в секунду

You Only Look Once: Unified, Real-Time Object Detection, 2015

Что такое YOLO?

YOLO это новейшая (на момент написания оригинальной статьи) система (сеть) обнаружения объектов. Она была разработана Джозефом Редмоном (Joseph Redmon). Наибольшим преимуществом YOLO над другими архитектурами является скорость. Модели семейства YOLO исключительно быстры и намного превосходят R-CNN (Region-Based Convolutional Neural Network) и другие модели. Это позволяет добиться обнаружения объектов в режиме реального времени.

На момент первой публикации (в 2016 году) по сравнению с другими системами, такими как R-CNN и DPM (Deformable Part Model), YOLO добилась передового значения mAP (mean Average Precision). С другой стороны, YOLO испытывает трудности с точной локализацией объектов. Однако в новой версии были внесены улучшения в скорости и точности системы.

Альтернативы (на момент публикации статьи): Другие архитектуры в основном использовали метод скользящего окна по всему изображению, и классификатор использовался для определенной области изображения (DPM). Также, R-CNN использовал метод предложения регионов (region proposal method). Описываемый метод сначала создает потенциальные bounding boxы. Затем, на области, ограниченные bounding boxами, запускается классификатор и следующее удаление повторяющихся распознаваний, и уточнение границ рамок.

YOLO переосмыслила задачу обнаружения объектов в задачу регрессии.Она идет от пикселей изображения к координатам bounding boxов и вероятностей классов. Тем самым, единая сверточная сеть предсказывает несколько bounding boxов и вероятности классов для содержания этих областей.

Теория

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

Во-первых, каждая ячейка отвечает за прогнозирование количества bounding boxов. Также, каждая ячейка прогнозирует доверительное значение (confidence value) для каждой области, ограниченной bounding boxом. Иными словами, это значение определяет вероятность нахождения того или иного объекта в данной области. То есть в случае, если какая-то ячейка сетки не имеет определенного объекта, важно, чтобы доверительное значение для этой области было низким.

Когда мы визуализируем все предсказания, мы получаем карту объектов и упорядоченных по доверительному значению, рамки.

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

Давайте подробней опишем вывод модели.

В YOLO используются anchor boxes (якорные рамки / фиксированные рамки) для прогнозирования bounding boxов. Идея anchor boxов сводится к предварительному определению двух различных форм. И таким образом, мы можем объединить два предсказания с двумя anchor boxами (в целом, мы могли бы использовать даже большее количество anchor boxов). Эти якоря были рассчитаны с помощью датасета COCO (Common Objects in Context) и кластеризации k-средних (K-means clustering).

У нас есть сетка, где каждая ячейка предсказывает:

• Для каждого bounding box'а:

  • 4 координаты (t_x , t_y , t_w , t_h)

  • 1 objectness error (ошибка объектности), которая является показателем уверенности в присутствии того или иного объекта

• Некоторое количество вероятностей классов

Если же присутствует некоторое смещение от верхнего левого угла на c_x , c_y то прогнозы будут соответствовать:

где p_w (ширина) и p_h (высота) соответствуют ширине и высоте bounding box'а. Вместо того, чтобы предугадывать смещение как в прошлой версии YOLOv2, авторы прогнозируют координаты местоположения относительно местоположения ячейки.

Этот вывод является выводом нашей нейронной сети. В общей сложности здесьS x S x [B * (4+1+C)] выводов, где B это количество bounding box'ов, которое может предсказать ячейка на карте объектов, C это количество классов, 4 для bounding box'ов, 1 для objectness prediction (прогнозирование объектности). За один проход мы можем пройти от входного изображения к выходному тензору, который соответствует обнаруженным объектам на картинке. Также стоит отметить, что YOLOv3 прогнозирует bounding box'ы в трех разных масштабах.

Теперь, если мы возьмем вероятность и умножим их на доверительные значения, мы получим все bounding box'ы, взвешенные по вероятности содержания этого объекта.

Простое нахождение порогового значения избавит нас от прогнозов с низким доверительным значением. Для следующего шага важно определить метрику IoU (Intersection over Union / Пересечение над объединением). Эта метрика равняется соотношению площади пересекающихся областей к площади областей объединенных.

После этого все равно могут остаться дубликаты, и чтобы от них избавиться нужно использовать подавление не-максимумов (non-maximum suppression). Подавление не-максимумов заключается в следующем: алгоритм берёт bounding box с наибольшей вероятностью принадлежности к объекту, затем, среди остальных граничащих bounding box'ов с данной области, возьмёт один с наивысшим IoU и подавляет его.

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

Мы также рекомендуем прочитать следующие статьи о YOLO:

• You Only Look Once: Unified, Real-Time Object Detection

• YOLO9000: Better, Faster, Stronger

• YOLOv3: An Incremental Improvement

Реализация в Tensorflow

Первым шагом в реализации YOLO это подготовка ноутбука и импортирование необходимых библиотек. Целиком ноутбук с кодом вы можете на Github или Kaggle:

Следуя этой статье, мы сделаем полную сверточную сеть (fully convolutional network / FCN) без обучения. Для того, чтобы применить эту сеть для определения объектов, нам необходимо скачать готовые веса от предварительно обученной модели. Эти веса были получены от обучения YOLOv3 на датасете COCO (Common Objects in Context). Файл с весами можно скачать по ссылке официального сайта.

# Создаем папку для checkpoint'ов с весами.# !mkdir checkpoints# Скачиваем файл с весами для YOLOv3 с официального сайта.# !wget https://pjreddie.com/media/files/yolov3.weights# Импортируем необходимые библиотеки.import cv2import numpy as np import tensorflow as tf from absl import loggingfrom itertools import repeatfrom PIL import Imagefrom tensorflow.keras import Modelfrom tensorflow.keras.layers import Add, Concatenate, Lambdafrom tensorflow.keras.layers import Conv2D, Input, LeakyReLUfrom tensorflow.keras.layers import MaxPool2D, UpSampling2D, ZeroPadding2Dfrom tensorflow.keras.regularizers import l2from tensorflow.keras.losses import binary_crossentropyfrom tensorflow.keras.losses import sparse_categorical_crossentropyyolo_iou_threshold = 0.6 # Intersection Over Union (iou) threshold.yolo_score_threshold = 0.6 # Score threshold.weightyolov3 = 'yolov3.weights' # Путь до файла с весами.size = 416 # Размер изображения. checkpoints = 'checkpoints/yolov3.tf' # Путь до файла с checkpoint'ом.num_classes = 80 # Количество классов в модели.# Список слоев в YOLOv3 Fully Convolutional Network (FCN).YOLO_V3_LAYERS = [    'yolo_darknet',    'yolo_conv_0',    'yolo_output_0',    'yolo_conv_1',    'yolo_output_1',    'yolo_conv_2',    'yolo_output_2']

По причине того, что порядок слоев в Darknet (open source NN framework) и tf.keras разные, то загрузить веса с помощью чистого функционального API будет проблематично. В этом случае, наилучшим решением будет создание подмоделей в keras. TF Checkpoints рекомендованы для сохранения вложенных подмоделей и они официально поддерживаются Tensorflow.

# Функция для загрузки весов обученной модели.def load_darknet_weights(model, weights_file):    wf = open(weights_file, 'rb')    major, minor, revision, seen, _ = np.fromfile(wf, dtype=np.int32, count=5)    layers = YOLO_V3_LAYERS    for layer_name in layers:        sub_model = model.get_layer(layer_name)        for i, layer in enumerate(sub_model.layers):            if not layer.name.startswith('conv2d'):                continue            batch_norm = None            if i + 1 < len(sub_model.layers) and \                sub_model.layers[i + 1].name.startswith('batch_norm'):                    batch_norm = sub_model.layers[i + 1]            logging.info("{}/{} {}".format(                sub_model.name, layer.name, 'bn' if batch_norm else 'bias'))                        filters = layer.filters            size = layer.kernel_size[0]            in_dim = layer.input_shape[-1]            if batch_norm is None:                conv_bias = np.fromfile(wf, dtype=np.float32, count=filters)            else:                bn_weights = np.fromfile(wf, dtype=np.float32, count=4*filters)                bn_weights = bn_weights.reshape((4, filters))[[1, 0, 2, 3]]            conv_shape = (filters, in_dim, size, size)            conv_weights = np.fromfile(wf, dtype=np.float32, count=np.product(conv_shape))            conv_weights = conv_weights.reshape(conv_shape).transpose([2, 3, 1, 0])            if batch_norm is None:                layer.set_weights([conv_weights, conv_bias])            else:                layer.set_weights([conv_weights])                batch_norm.set_weights(bn_weights)    assert len(wf.read()) == 0, 'failed to read weights'    wf.close()

На этом же этапе, мы должны определить функцию для расчета IoU. Мы используем batch normalization (пакетная нормализация) для нормализации результатов, чтобы ускорить обучение. Так как tf.keras.layers.BatchNormalization работает не очень хорошо для трансферного обучения (transfer learning), то мы используем другой подход.

# Функция для расчета IoU.def interval_overlap(interval_1, interval_2):    x1, x2 = interval_1    x3, x4 = interval_2    if x3 < x1:        return 0 if x4 < x1 else (min(x2,x4) - x1)    else:        return 0 if x2 < x3 else (min(x2,x4) - x3)def intersectionOverUnion(box1, box2):    intersect_w = interval_overlap([box1.xmin, box1.xmax], [box2.xmin, box2.xmax])    intersect_h = interval_overlap([box1.ymin, box1.ymax], [box2.ymin, box2.ymax])    intersect_area = intersect_w * intersect_h    w1, h1 = box1.xmax-box1.xmin, box1.ymax-box1.ymin    w2, h2 = box2.xmax-box2.xmin, box2.ymax-box2.ymin    union_area = w1*h1 + w2*h2 - intersect_area    return float(intersect_area) / union_area class BatchNormalization(tf.keras.layers.BatchNormalization):    def call(self, x, training=False):        if training is None: training = tf.constant(False)        training = tf.logical_and(training, self.trainable)        return super().call(x, training)# Определяем 3 anchor box'а для каждой ячейки.   yolo_anchors = np.array([(10, 13), (16, 30), (33, 23), (30, 61), (62, 45),                        (59, 119), (116, 90), (156, 198), (373, 326)], np.float32) / 416yolo_anchor_masks = np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]])

В каждом масштабе мы определяем 3 anchor box'а для каждой ячейки. В нашем случае если маска будет:

• 0, 1, 2 означает, что будут использованы первые три якорные рамки

• 3, 4 ,5 означает, что будут использованы четвертая, пятая и шестая

• 6, 7, 8 означает, что будут использованы седьмая, восьмая, девятая

# Функция для отрисовки bounding box'ов.def draw_outputs(img, outputs, class_names, white_list=None):    boxes, score, classes, nums = outputs    boxes, score, classes, nums = boxes[0], score[0], classes[0], nums[0]    wh = np.flip(img.shape[0:2])    for i in range(nums):        if class_names[int(classes[i])] not in white_list:            continue        x1y1 = tuple((np.array(boxes[i][0:2]) * wh).astype(np.int32))        x2y2 = tuple((np.array(boxes[i][2:4]) * wh).astype(np.int32))        img = cv2.rectangle(img, x1y1, x2y2, (255, 0, 0), 2)        img = cv2.putText(img, '{} {:.4f}'.format(            class_names[int(classes[i])], score[i]),            x1y1, cv2.FONT_HERSHEY_COMPLEX_SMALL, 1, (0, 0, 255), 2)    return img

Теперь пришло время для реализации YOLOv3. Идея заключается в том, чтобы использовать только сверточные слои. Так как их здесь 53, то самым простым способом является создание функции, в которую мы будем передавать важные параметры, меняющиеся от слоя к слою.

Остаточные блоки (Residual Blocks) в диаграмме архитектуры YOLOv3 применяются для изучения признаков. Остаточный блок содержит в себе несколько сверточных слоев и дополнительные связи для обхода этих слоев.

Создавая нашу модель, мы строим нашу модель с помощью функционального API, который будет легко использовать. С его помощью мы можем без труда определить ветви в нашей архитектуре (ResNet Block) и делить слои внутри архитектуры.

def DarknetConv(x, filters, size, strides=1, batch_norm=True):    if strides == 1:        padding = 'same'    else:        x = ZeroPadding2D(((1, 0), (1, 0)))(x)        padding = 'valid'    x = Conv2D(filters=filters, kernel_size=size,              strides=strides, padding=padding,              use_bias=not batch_norm, kernel_regularizer=l2(0.0005))(x)    if batch_norm:        x = BatchNormalization()(x)        x = LeakyReLU(alpha=0.1)(x)    return xdef DarknetResidual(x, filters):    previous = x    x = DarknetConv(x, filters // 2, 1)    x = DarknetConv(x, filters, 3)    x = Add()([previous , x])    return xdef DarknetBlock(x, filters, blocks):    x = DarknetConv(x, filters, 3, strides=2)    for _ in repeat(None, blocks):        x = DarknetResidual(x, filters)           return xdef Darknet(name=None):    x = inputs = Input([None, None, 3])    x = DarknetConv(x, 32, 3)    x = DarknetBlock(x, 64, 1)    x = DarknetBlock(x, 128, 2)    x = x_36 = DarknetBlock(x, 256, 8)    x = x_61 = DarknetBlock(x, 512, 8)    x = DarknetBlock(x, 1024, 4)    return tf.keras.Model(inputs, (x_36, x_61, x), name=name)  def YoloConv(filters, name=None):    def yolo_conv(x_in):        if isinstance(x_in, tuple):            inputs = Input(x_in[0].shape[1:]), Input(x_in[1].shape[1:])            x, x_skip = inputs            x = DarknetConv(x, filters, 1)            x = UpSampling2D(2)(x)            x = Concatenate()([x, x_skip])        else:            x = inputs = Input(x_in.shape[1:])        x = DarknetConv(x, filters, 1)        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, filters, 1)        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, filters, 1)        return Model(inputs, x, name=name)(x_in)    return yolo_conv  def YoloOutput(filters, anchors, classes, name=None):    def yolo_output(x_in):        x = inputs = Input(x_in.shape[1:])        x = DarknetConv(x, filters * 2, 3)        x = DarknetConv(x, anchors * (classes + 5), 1, batch_norm=False)        x = Lambda(lambda x: tf.reshape(x, (-1, tf.shape(x)[1], tf.shape(x)[2],                                        anchors, classes + 5)))(x)        return tf.keras.Model(inputs, x, name=name)(x_in)    return yolo_outputdef yolo_boxes(pred, anchors, classes):    grid_size = tf.shape(pred)[1]    box_xy, box_wh, score, class_probs = tf.split(pred, (2, 2, 1, classes), axis=-1)    box_xy = tf.sigmoid(box_xy)    score = tf.sigmoid(score)    class_probs = tf.sigmoid(class_probs)    pred_box = tf.concat((box_xy, box_wh), axis=-1)    grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))    grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)    box_xy = (box_xy + tf.cast(grid, tf.float32)) /  tf.cast(grid_size, tf.float32)    box_wh = tf.exp(box_wh) * anchors    box_x1y1 = box_xy - box_wh / 2    box_x2y2 = box_xy + box_wh / 2    bbox = tf.concat([box_x1y1, box_x2y2], axis=-1)        return bbox, score, class_probs, pred_box

Теперь определим функцию подавления не-максимумов.

def nonMaximumSuppression(outputs, anchors, masks, classes):    boxes, conf, out_type = [], [], []    for output in outputs:        boxes.append(tf.reshape(output[0], (tf.shape(output[0])[0], -1, tf.shape(output[0])[-1])))        conf.append(tf.reshape(output[1], (tf.shape(output[1])[0], -1, tf.shape(output[1])[-1])))        out_type.append(tf.reshape(output[2], (tf.shape(output[2])[0], -1, tf.shape(output[2])[-1])))    bbox = tf.concat(boxes, axis=1)    confidence = tf.concat(conf, axis=1)    class_probs = tf.concat(out_type, axis=1)    scores = confidence * class_probs      boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(        boxes=tf.reshape(bbox, (tf.shape(bbox)[0], -1, 1, 4)),        scores=tf.reshape(            scores, (tf.shape(scores)[0], -1, tf.shape(scores)[-1])),        max_output_size_per_class=100,        max_total_size=100,        iou_threshold=yolo_iou_threshold,        score_threshold=yolo_score_threshold)      return boxes, scores, classes, valid_detections

Основная функция:

def YoloV3(size=None, channels=3, anchors=yolo_anchors,            masks=yolo_anchor_masks, classes=80, training=False):    x = inputs = Input([size, size, channels])    x_36, x_61, x = Darknet(name='yolo_darknet')(x)    x = YoloConv(512, name='yolo_conv_0')(x)    output_0 = YoloOutput(512, len(masks[0]), classes, name='yolo_output_0')(x)    x = YoloConv(256, name='yolo_conv_1')((x, x_61))    output_1 = YoloOutput(256, len(masks[1]), classes, name='yolo_output_1')(x)    x = YoloConv(128, name='yolo_conv_2')((x, x_36))    output_2 = YoloOutput(128, len(masks[2]), classes, name='yolo_output_2')(x)    if training:        return Model(inputs, (output_0, output_1, output_2), name='yolov3')    boxes_0 = Lambda(lambda x: yolo_boxes(x, anchors[masks[0]], classes),                  name='yolo_boxes_0')(output_0)    boxes_1 = Lambda(lambda x: yolo_boxes(x, anchors[masks[1]], classes),                  name='yolo_boxes_1')(output_1)    boxes_2 = Lambda(lambda x: yolo_boxes(x, anchors[masks[2]], classes),                  name='yolo_boxes_2')(output_2)    outputs = Lambda(lambda x: nonMaximumSuppression(x, anchors, masks, classes),                  name='nonMaximumSuppression')((boxes_0[:3], boxes_1[:3], boxes_2[:3]))    return Model(inputs, outputs, name='yolov3')

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

def YoloLoss(anchors, classes=80, ignore_thresh=0.5):    def yolo_loss(y_true, y_pred):        pred_box, pred_obj, pred_class, pred_xywh = yolo_boxes(            y_pred, anchors, classes)        pred_xy = pred_xywh[..., 0:2]        pred_wh = pred_xywh[..., 2:4]        true_box, true_obj, true_class_idx = tf.split(            y_true, (4, 1, 1), axis=-1)        true_xy = (true_box[..., 0:2] + true_box[..., 2:4]) / 2        true_wh = true_box[..., 2:4] - true_box[..., 0:2]        box_loss_scale = 2 - true_wh[..., 0] * true_wh[..., 1]        grid_size = tf.shape(y_true)[1]        grid = tf.meshgrid(tf.range(grid_size), tf.range(grid_size))        grid = tf.expand_dims(tf.stack(grid, axis=-1), axis=2)        true_xy = true_xy * tf.cast(grid_size, tf.float32) - \            tf.cast(grid, tf.float32)        true_wh = tf.math.log(true_wh / anchors)        true_wh = tf.where(tf.math.is_inf(true_wh),                      tf.zeros_like(true_wh), true_wh)        obj_mask = tf.squeeze(true_obj, -1)        true_box_flat = tf.boolean_mask(true_box, tf.cast(obj_mask, tf.bool))        best_iou = tf.reduce_max(intersectionOverUnion(            pred_box, true_box_flat), axis=-1)        ignore_mask = tf.cast(best_iou < ignore_thresh, tf.float32)        xy_loss = obj_mask * box_loss_scale * \            tf.reduce_sum(tf.square(true_xy - pred_xy), axis=-1)        wh_loss = obj_mask * box_loss_scale * \            tf.reduce_sum(tf.square(true_wh - pred_wh), axis=-1)        obj_loss = binary_crossentropy(true_obj, pred_obj)        obj_loss = obj_mask * obj_loss + \            (1 - obj_mask) * ignore_mask * obj_loss        class_loss = obj_mask * sparse_categorical_crossentropy(            true_class_idx, pred_class)        xy_loss = tf.reduce_sum(xy_loss, axis=(1, 2, 3))        wh_loss = tf.reduce_sum(wh_loss, axis=(1, 2, 3))        obj_loss = tf.reduce_sum(obj_loss, axis=(1, 2, 3))        class_loss = tf.reduce_sum(class_loss, axis=(1, 2, 3))        return xy_loss + wh_loss + obj_loss + class_loss    return yolo_loss

Функция "преобразовать цели" возвращает кортеж из форм:

(    [N, 13, 13, 3, 6],    [N, 26, 26, 3, 6],    [N, 52, 52, 3, 6])

Где N число меток в пакете, а число 6 означает [x, y, w, h, obj, class] bounding box'а.

@tf.functiondef transform_targets_for_output(y_true, grid_size, anchor_idxs, classes):    N = tf.shape(y_true)[0]    y_true_out = tf.zeros(      (N, grid_size, grid_size, tf.shape(anchor_idxs)[0], 6))    anchor_idxs = tf.cast(anchor_idxs, tf.int32)    indexes = tf.TensorArray(tf.int32, 1, dynamic_size=True)    updates = tf.TensorArray(tf.float32, 1, dynamic_size=True)    idx = 0    for i in tf.range(N):        for j in tf.range(tf.shape(y_true)[1]):            if tf.equal(y_true[i][j][2], 0):                continue            anchor_eq = tf.equal(                anchor_idxs, tf.cast(y_true[i][j][5], tf.int32))            if tf.reduce_any(anchor_eq):                box = y_true[i][j][0:4]                box_xy = (y_true[i][j][0:2] + y_true[i][j][2:4]) / 2                anchor_idx = tf.cast(tf.where(anchor_eq), tf.int32)                grid_xy = tf.cast(box_xy // (1/grid_size), tf.int32)                indexes = indexes.write(                    idx, [i, grid_xy[1], grid_xy[0], anchor_idx[0][0]])                updates = updates.write(                    idx, [box[0], box[1], box[2], box[3], 1, y_true[i][j][4]])                idx += 1    return tf.tensor_scatter_nd_update(        y_true_out, indexes.stack(), updates.stack())def transform_targets(y_train, anchors, anchor_masks, classes):    outputs = []    grid_size = 13    anchors = tf.cast(anchors, tf.float32)    anchor_area = anchors[..., 0] * anchors[..., 1]    box_wh = y_train[..., 2:4] - y_train[..., 0:2]    box_wh = tf.tile(tf.expand_dims(box_wh, -2),                    (1, 1, tf.shape(anchors)[0], 1))    box_area = box_wh[..., 0] * box_wh[..., 1]    intersection = tf.minimum(box_wh[..., 0], anchors[..., 0]) * \    tf.minimum(box_wh[..., 1], anchors[..., 1])    iou = intersection / (box_area + anchor_area - intersection)    anchor_idx = tf.cast(tf.argmax(iou, axis=-1), tf.float32)    anchor_idx = tf.expand_dims(anchor_idx, axis=-1)    y_train = tf.concat([y_train, anchor_idx], axis=-1)    for anchor_idxs in anchor_masks:        outputs.append(transform_targets_for_output(            y_train, grid_size, anchor_idxs, classes))        grid_size *= 2    return tuple(outputs) # [x, y, w, h, obj, class]def preprocess_image(x_train, size):    return (tf.image.resize(x_train, (size, size))) / 255

Теперь мы можем создать нашу модель, загрузить веса и названия классов. В COCO датасете их 80.

yolo = YoloV3(classes=num_classes)load_darknet_weights(yolo, weightyolov3)yolo.save_weights(checkpoints)class_names =  ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck",    "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",    "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe",    "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard",    "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",    "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl",    "banana","apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",    "cake","chair", "sofa", "pottedplant", "bed", "diningtable", "toilet", "tvmonitor", "laptop",     "mouse","remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",    "refrigerator","book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]def detect_objects(img_path, white_list=None):    image = img_path     # Путь к изображению.    img = tf.image.decode_image(open(image, 'rb').read(), channels=3)    img = tf.expand_dims(img, 0)    img = preprocess_image(img, size)    boxes, scores, classes, nums = yolo(img)    img = cv2.imread(image)    img = draw_outputs(img, (boxes, scores, classes, nums), class_names, white_list)    cv2.imwrite('detected_{:}'.format(img_path), img)    detected = Image.open('detected_{:}'.format(img_path))    detected.show()    detect_objects('test.jpg', ['bear'])

Итог

В этой статье мы поговорили об отличительных особенностях YOLOv3 и её преимуществах перед другими моделями. Мы рассмотрели способ реализации с использованием TensorFlow 2.0 (TF должен быть не менее версией 2.0).

Ссылки

• Полная реализация YOLOv3 на Tensorflow 2.0

• Реализация YOLOv3 из текущей статьи

• YOLOv3 - Joseph Redmon