Нейросети и CV — основы теории и практика — система машинного зрения на одноплатнике Repka Pi / forpes.ru

Главная
Нейросети и CV — основы теории и практика — система машинного зрения на одноплатнике Repka Pi

Нейросети и CV — основы теории и практика — система машинного зрения на одноплатнике Repka Pi

25.06.2024 12:14

RyabovA 0 2400 Источник

Одно из интересных и полезных применений нейросетей — обнаружение объектов на изображении, таких как машины, люди или человеческие лица.

Вы давно хотели начать погружение в глубокий и захватывающий Мир ИИ и распознавания? А может быть хотите сделать свою интеллектуальную систему наблюдения, оповещения или даже принятия решений для управления каким то процессом или устройствами? Тогда эта статья точно Вас заинтересует, так как тут сделана попытка дать необходимые основы работы и практическую пошаговую инструкцию, следуя которой Вы получите впечатляющие результаты даже в домашних условиях или в учебном классе, такие, которые ранее видели только на выставках или в фильмах и уже после этого сможете создать свои собственные проекты для оповещения и/или управления с использованием ИИ и компьютерного зрения, уже ограничивая их только своей фантазией и количеством уделенного времени, а в процессе так же охватите освоение современного IT стека. Правда для этого Вам лучше заодно обзавестись одноплатным компьютером на процессоре архитектуры ARM, это позволит использовать все специально собранные и подготовленные для этого исходные коды программ, которые рассматриваются в практической части этой статьи, а так же в дальнейшем использовать промышленные интерфейсы Вашего одноплатника для автоматизации взаимодействия с исполнительными устройствами, если Вы захотите, например, управлять включения освещения, реле подачи питания, сигналами замков или чем то другим на Ваше усмотрение, а ещё одноплатник можно будет поставить для непрерывной круглосуточной работы в качестве сервера системы компьютерного зрения.

Компьютерное (или как ещё часто говорят, машинное) зрение (Computer Vision, сокращённо CV) — область искусственного интеллекта, которая занимается созданием программ и систем, позволяющих анализировать и понимать содержимое на изображениях и видео. Этот процесс выходит за рамки простого наблюдения, обучая компьютеры принимать решения на основе увиденного, просто сообщая о результатах детектирования или даже принимая сложные решения для управления процессами в самых разных областях деятельности.

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

Вы, наверное, слышали, что для работы нейронных сетей требуются большие вычислительные мощности. После чтения нашей статьи вы сможете убедиться, что обнаружение объектов на уже обученных моделях нейросетей доступно для устройств с микрокомпьютерами, такими как Repka Pi.

В этой статье мы рассмотрим основные понятия нейронных сетей. Затем мы расскажем, как добавить функции обнаружения лиц и людей в видеопотоке от обычной веб-камеры, подключенной через USB к Repka Pi. При этом будут использованы каскады Хаара, нейросеть Yolo-FastestV2, фреймворки OpenCV и NCNN, а также репозиторий ml-repka от компании Rainbowsoft.

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

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

Нейроны человеческого мозга

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

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

Устройство нейрона схематически показано на рис. 1.

Не вдаваясь в детали, расскажем кратко о работе нейронов.

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

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

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

Эти нейромедиаторы могут возбудить или подавить активность другого нейрона, «подключенного» к аксону другого нейрона через синаптическое пространство между нейронами.

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

Математическая модель нейрона

Для моделирования нейронных сетей с помощью компьютеров была создана сильно упрощенная математическая модель нейрона (рис. 2).

Здесь входные сигналы X0…Xn попадают на вход взвешенного сумматора, при этом веса W0…Wn определяют «вклад» каждого сигнала на итоговую сумму Sum. Этот вклад может быть положительным или отрицательным, увеличивающим или уменьшающим значение суммы. Сигнал W0 и соответствующий ему вес W0 может использоваться для инициализации нейрона.

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

На практике применяются линейные и сигмоидные функции, функции гиперболического тангенса, функции Rectified Linear Unit (выпрямленный линейный блок), Leaky ReLU и другие (рис. 3). В статье Функция активации вы найдете описания, сравнение и графики различных функций.

**Рис. 3. Некоторые из функций активации.**

Какую из функций следует использовать?

Тут нет однозначного ответа. Функция активации влияет на скорость обучения и работы сети. Она может подбираться в процессе экспериментов или исследований. Когда вы имеете дело с готовыми моделями нейросетей и фреймворками, вам не придется выбирать функцию активации самостоятельно.

Архитектуры нейронных сетей

Рассмотрим некоторые архитектуры и алгоритмы нейронных сетей — перцептрон, сверточные сети, YOLO и каскады Хаара.

Перцептрон

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

На рис. 4 мы показали так называемый перцептрон — простейший вид нейронной сети.

**Рис. 4. Использование перцептрона для распознавания цифр.**

Представленный на рис. 4 перцептрон состоит из входного и выходного слоев. Предполагается, что этот перцептрон используется для распознавания цифр в диапазоне от 0 до 9.

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

Выходы нейронов первого слоя соединены со входами второго, выходного слоя нейронов. Хотя на рис. 4 это и не показано, предполагается, что каждый выход нейрона входного слоя соединен со входами всех нейронов выходного слоя.

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

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

Для обучения данной сети используется так называемый метод коррекции ошибки.

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

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

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

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

Сверточные сети

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

Представьте себе, что размер изображения составляет 640 на 480 пикселов. При этом во входной нейронной сети, подобной описанной выше, нужно будет использовать 307 200 нейронов.

Если нужно распознавать, например, 2000 объектов, то в выходном слое будет 2000 нейронов. Каждый выход 307 200 входных нейронов нужно будет подключить ко всем входам 2000 выходных нейронов. Получится, что между входным и выходным слоями будет нужно создать 2000 * 307 200 связей. Итого будет 614 400 000 связей, и для каждой связи в процессе обучения нужно будет настраивать свой вес. Таким образом, обучение превращается в очень сложную и ресурсоемкую процедуру.

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

Но наша нас цель — организовать обнаружение объектов, для которых обучение не выполнялось, причем в реальном времени. Например, обнаружить и выделить на фотографии или в видеопотоке лица или фигуры людей (или других объектов), которые нейронная сеть никогда не «видела».

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

Для решения задач компьютерного зрения, классификации и сегментации изображений, а также для обнаружения объектов были созданы так называемые сверточные нейронные сети (Convolutional Neural Network, CNN).

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

На рис. 5 показана архитектура сверточной нейронной сети.

**Рис. 5. Архитектура сверточной нейронной сети.**

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

сверточные слои (Convolutional Layers);
слои подвыборки (Pooling Layers);
слой активации;
полносвязные слои (Fully Connected Layers)

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

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

Слой активации играет роль функции активации, которая применяется к каждому числу входного изображения (рис. 3). Слой активации может быть встроен в сверточный слой, и не показан на рис. 5.

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

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

Операция обучения сверточной сети, как и перцептрона, длительная и достаточно ресурсоемкая.

Алгоритм обнаружения объектов YOLO

Алгоритм YOLO («Вы смотрите только один раз», You Only Look Once) представляет собой чрезвычайно быстрый алгоритм обнаружения объектов, использующий сверточную нейронную сеть, и способный работать в режиме реального времени.

Алгоритм YOLO был представлен в 2015 году Джозефом Редмоном, Сантошем Диввалой, Россом Гиршиком и Али Фархади в исследовательской работе You Only Look Once: Unified, Real-Time Object Detection.

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

При использовании YOLO для ускорения обнаружения объектов предлагается выбрать в изображении некоторое фиксированное количество прямоугольников и для каждого прямоугольника проверить наличие искомого объекта. Если объект найден, для него определяется класс принадлежности и координаты рамки, окружающей этот объект — bounding box.

На рис. 6 показано обнаружение лиц, выполненное с помощью микрокомпьютера Repka Pi.

**Рис. 6. Обнаружение лиц с помощью Repka Pi.**

Класс принадлежности объекта — это такие категории, как «автомобиль», «дом», «пешеход», «стол», «машина», «грузовик», «автобус» и так далее.

Для каждого обнаруженного объекта YOLO возвращает рамку, окружающую этот объект (bounding box), а также вероятность принадлежности к тому или иному классу.

Скорость базовой модели YOLO, по сообщениям ее создателя, такова, что она способна обрабатывать изображения в режиме реального времени со скоростью 45 кадров в секунду (с использованием процессора Titan X GPU). Скорость обработки сети Fast YOLO достигает 155 кадров в секунду.

Как достигается такая высокая скорость обработки?

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

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

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

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

Каскады Хаара

В одной из программ, приведенных в этой статье, мы будем использовать каскады Хаара. Этот классический метод компьютерного зрения был предложен Паулем Виолой и Майклом Джонсом еще в 2001 году. Он основан на применении набора простых признаков (например, границы и текстуры) к изображению с использованием фильтров Хаара.

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

Другие архитектуры

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

Сборка макета для обнаружения лиц и людей

А теперь перейдем к практической части — на базе микрокомпьютера Repka Pi и видеокамеры USB соберем макет, способный обнаруживать в видеопотоке лица и фигуры людей.

Подключите к разъему USB микрокомпьютера Repka Pi веб-камеру, такую как Logitech HD 720p или аналогичную (рис. 7.1).

**Рис. 7.1. Веб-камера Logitech HD 720p подключена к Repka Pi через USB.**

Мы будем обнаруживать и выделять в потоке данных от веб-камеры лица и людей.

Желательно, чтобы в микрокомпьютере была установлена память объемом не менее 2 ГБайт. Это сильно ускорит сборку необходимого ПО, особенно фреймворка OpenCV.

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

Repka Pi - это относительно недавно появившиеся на рынке одноплатники, ставшие Российской альтернативой известному проекту Raspberry Pi, ссылку на сайт проекта в данной статье не приводим, так как это противоречит правилам данной площадки.

Установка Repka OS

Перейдем к установке ПО. Прежде всего, скачайте образ Repka OS по ссылке на раздел с образами прошивки. Мы использовали образ версию прошивки от 13.06.24, так как как раз разработчики объявили, что провели адаптацию и доработку операционной системы для работы именно с нейронными сетями, сделав её стабильной и более эффективной в сравнении с предыдущими версиями операционной системы - эта версия (или выше) рекомендуется для работы с нейросетями, так как в ней доработаны параметры работы регулятора питания на длительных непрерывных максимально высоких нагрузках при большом объёме данных передаваемых в оперативную память. Эта версия Repka OS доступна для всех версий плат Repka Pi 3, а мы применяли два экземпляра - версии 1.3 и версии 1.6, но для версии 1.6 выбрали вариант, предназначенный для варианта режима работы с активным охлаждением, так как без охлаждения одноплатники на задачах распознавания могут греться и снижать частоту работы, это называется тротлить, что будет приводить к снижению производительности, а на таких задачах это не очень интересно, а точнее совсем не интересно.

Запишите образ на карту памяти, объемом не менее 32 Гбайт.

**Рис. 7.1. Как выглядит раздел сайта для скачивания прошивки.**

Из консоли обновите пакеты:

# apt update
# apt upgrade

Далее для настройки производительности запустите программу repka-config:

# repka-config

Выберите в меню строку 3 Interface Options (Настройка подключения и интерфейсов), затем I2 Frequency / pinout Options (Настройка производительности и распиновки).

Для Repka Pi версии 1.3 мы выбрали частоту 1.368 ГГц (рис. 8), а для Repka Pi версии 1.6 — частоту 1.416 ГГц с активным охлаждением.

Если у вас Repka Pi с платой версии 1.4, 1.5 или 1.6, для максимальной производительности, выбирайте вариант с максимальной частотой процессора и с активным охлаждением. И, конечно, не забудьте установить вентилятор.

Мы запускали ПО на Repka Pi версии 1.3, поэтому выбрали первый вариант распиновки. После выбора мы перезагрузили Repka OS.

Далее нам потребуется ядро ОС 6.1.11. Запустите программу repka-config. Выберите строку System Options (Настройка системы), затем строку S1 Select-Kernel (Выбрать ядро Linux). Вы увидите текущую версию ядра. Далее нажмите кнопку OK и выберите ядро 6.1.11-sunxi64 (рис. 9).

После перезагрузки проверьте версию ядра:

# uname -a
Linux Repka-Pi 6.1.11 #2 SMP Wed Jan 17 16:29:59 +04 2024 aarch64 aarch64 aarch64 GNU/Linux

Загрузка файлов репозитория

Теперь можно переходить к установке репозитория и фреймворков.

Прежде всего создайте рабочий каталог, например, workspace, и загрузите и распакуйте файлы репозитория ml-repka:

# mkdir workspace && cd workspace
# git clone https://gitflic.ru/project/repka_pi/ml-repka.git

Установка Golang

Скачайте и распакуйте файлы Golang:

# wget https://go.dev/dl/go1.22.3.linux-arm64.tar.gz
# tar -C /usr/local -xzf go1.22.3.linux-arm64.tar.gz

Файлы будут распакованы в каталог /usr/local, поэтому распаковку нужно выполнять с правами пользователя root.

Отредактируйте файл ~/.profile или ~/.bashrc, добавив в конце файла строку:

export PATH=$PATH:/usr/local/go/bin

Актуализируйте файл профиля и проверьте версию Golang:

# source ~/.profile
# go version
go version go1.22.3 linux/arm64

Установка OpenCV

На следующем этапе мы будем собирать и устанавливать OpenCV.

Библиотека (фреймворк) OpenCV (Open Source Computer Vision Library) предназначена для разработки приложений компьютерного зрения. В ней имеется набор инструментов и функций для работы с изображениями и видео, обнаружения объектов, анализа движения, калибровки камер, создания графических интерфейсов и многого другого.

Для выполнения установки OpenCV потребуется дополнительная память, поэтому размер файла Swap надо будет увеличить до 6 ГБайт, а затем перезагрузить ОС:

# swapoff /swapfile 
# fallocate -l 6G /swapfile 
# mkswap /swapfile 
# swapon /swapfile 
# reboot

После выполнения этих команд и перезагрузки убедитесь, что размер Swap увеличился до 6 Гбайт:

# swapon --show
NAME      TYPE SIZE USED PRIO
/swapfile file   6G   0B   -2

Если у вас Repka Pi с объемом оперативной памяти 1 Гбайт, необходимо на время установки увеличить размер раздела /tmp, размер которого по умолчанию составляет 477 MБайт. Для увеличения до 1 ГБайт используйте такую команду:

# mount -o remount,size=1G /tmp

Проверьте, что размер раздела увеличился:

# df -h /tmp
Файл.система   Размер Использовано  Дост Использовано% Cмонтировано в
tmpfs            1,0G         4,0K  1,0G            1% /tmp

После перезагрузки ОС размер этого раздела станет прежним.

Далее для установки OpenCV перейдите в каталог install репозитория ml-repka и запустите установку:

# cd workspace/ml-repka/install
# time make install_raspi

С помощью команды time мы можем измерить длительность работы команды make.

Заметим, что на Repka Pi с объемом оперативной памяти 1 Гбайт сборка OpenCV может идти очень долго.

После завершения установки проверьте версию OpenCV:

# opencv_version
4.9.0

Если вам будут нужна дополнительные модели для нейросетей, то вы сможете их найти по адресу: https://download.repka-pi.ru/ml/. Загрузите их в следующие каталоги:

yolov3.weights ==> humandetect_yolo/data (предварительно обученные веса для модели YOLOv3);
frozen_inference_graph.pb ==> humandetect_tf/data (архитектура модели и обученные веса модели TensorFlow)
yolov3-tiny.weights ==> humandetect_yolo_tiny/data (предварительно обученные веса для модели YOLOv3-Tiny)

Установка библиотеки NCNN

Библиотека NCNN (Nihui Convolutional Neural Network) представляет собой библиотеку глубокого обучения с открытым исходным кодом. Эта библиотека оптимизирована для работы на мобильных и встраиваемых устройствах. С ее помощью можно эффективно выполнять инференс (прогнозирование) нейронных сетей на устройствах с ограниченными вычислительными ресурсами. Как мы уже говорили, инференс — это процесс работы обученной нейросети на конечном устройстве, или конечный результат обработки данных.

Для установки NCNN перейдите в рабочий каталог, выполните клонирование репозитория, а затем перейдите в полученный таким образом каталог:

# cd workspace
# git clone https://github.com/Tencent/ncnn.git
# cd ncnn

Далее обновите сабмодули репозитория:

# git submodule update --init

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

# mkdir build && cd build
# cmake -DCMAKE_BUILD_TYPE=Release -DNCNN_BUILD_EXAMPLES=ON -DNCNN_BUILD_TOOLS=OFF ..

Запустите сборку (это длительный процесс), а после ее завершения — установку NCNN:

# make -j2
# make install

Для установки переменной среды ncnn_DIR добавьте в файл ~/.profile или ~/.bashrc следующую строку:

export ncnn_DIR=/root/workspace/ncnn/build/install/lib/cmake/ncnn

Далее активируйте изменения в профиле:

# source ~/.profile

Вы также можете ознакомиться с документацией по установке репозитория ml-repka от компании Rainbowsoft.

Запуск программ обнаружения

Чтобы оценить возможности CV на микрокомпьютере Repka Pi, давайте запустим некоторые программы, размещенные в репозитории ml-repka и специально подготовленные для запуска и работы на одноплатном компьютере Repka Pi. Это программы обнаружения лиц, людей, а также программа сегментации людей.

Программа обнаружения лиц run-facedetect

Чтобы запустить программу обнаружения лиц в потоке от видеокамеры run-facedetect, перейдите в репозиторий ml-repka и соберите программу с помощью make:

# cd workspace/ml-repka
# make build-facedetect

Далее запустите программу:

# make run-facedetect

Если программа не запускается, потому что не находит камеру, установите значение SOURCE равным 1 в файле workspace/ml_repka/Makefile и запустите команду «make build-facedetect» заново.

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

Прежде всего, используйте команду lsusb:

# lsusb
Bus 008 Device 002: ID 046d:c31c Logitech, Inc. Keyboard K120
Bus 008 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 007 Device 002: ID 046d:c05a Logitech, Inc. M90/M100 Optical Mouse
Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 002: ID 046d:0825 Logitech, Inc. Webcam C270
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

В данном случае команда нашла веб-камеру Logitech, Inc. Webcam C270.

Далее при помощи следующей команды можно посмотреть список доступных устройств захвата:

# ls /dev/video*
/dev/video0  /dev/video1  /dev/video2

И, наконец, команда ffmpeg позволит вам не только проверить наличие веб-камеры, но и покажет доступные форматы видео для вашей веб-камеры, включая разрешения и кодеки, поддерживаемые каждым форматом:

# ffmpeg -f v4l2 -list_formats all -i /dev/video1
ffmpeg version 4.2.7-0ubuntu0.1 Copyright (c) 2000-2022 the FFmpeg developers
  built with gcc 9 (Ubuntu 9.4.0-1ubuntu1~20.04.1)
  configuration: --prefix=/usr --extra-version=0ubuntu0.1 --toolchain=hardened --libdir=/usr/lib/aarch64-linux-gnu –
…
libpostproc    55.  5.100 / 55.  5.100
[video4linux2,v4l2 @ 0xaaab2345e760] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
[video4linux2,v4l2 @ 0xaaab2345e760] Compressed:       mjpeg :          Motion-JPEG : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960

После запуска программы run-facedetect мы направили веб-камеру на сайт Repka Pi. Результат обнаружения лиц показан на рис. 10.

**Рис. 10. Результат работы программы facedetect.**

Как видите, здесь выделяются рамкой лица и так называемые метки лица — цветные точки. На рис. 11 показано исходное изображение и результат обнаружения лица в более крупном масштабе.

**Рис. 11. Результаты обнаружения лица.**

Метки лица (face landmarks) представляют собой точки, расположенные на ключевых областях лица, таких как глаза, нос, рот и так далее. Могут использоваться для обнаружения и отслеживания лиц, в качестве ориентиров для определения положения и ориентации лица в пространстве, для распознавания эмоций и выражений лица и других операций.

Программы обнаружения людей run-humandetect

Теперь испытаем Repka Pi и YOLO для решения другой задачи — обнаружения людей и других объектов в потоке данных от веб-камеры.

Перейдите в репозиторий ml-repka и соберите программу с помощью make:

# cd workspace/ml-repka
# make build-humandetect

После сборки запустите программу:

# make run-humandetect

Результат работы программы обнаружения humandetect, запущенной на Repka Pi, показан на рис. 12.

**Рис. 12. Результат работы программы обнаружения объектов.**

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

На рис. 13 показано, как с помощью программы humandetect можно обрабатывать изображение трафика загруженного шоссе.

**Рис. 13. Обработка фото трафика загруженного шоссе.**

Как видите, программа обнаружила здесь автомобили класса car, автобус класса bus, а также грузовую машину класса truck.

Программа сегментации людей humanseg

Программа humanseg может выполнить сегментацию людей. Запустите ее следующей командой:

# make humanseg

Направьте веб-камеру на изображение, где есть несколько человек, и вы увидите результат сегментации (рис. 15).

**Рис. 15. Сегментация людей с помощью humanseg.**

Здесь мы использовали исходное изображение, открытое на сайте Freepik.

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

Как это видно на рис. 15, при сегментации могут возникать ошибки.

Другие программы обнаружения

В репозитории ml-repka есть и другие программы обнаружения. Чтобы узнать их список и получить краткое описание, введите команду:

# make help

На рис. 14 мы показали часть программ, которые можно запускать на Репке (без докера).

**Рис. 14. Некоторые программы из репозитория ml-repka.**

Мы оставим эти программы вам на самостоятельное изучение.

В статье Deep learning examples on Raspberry 32/64 OS вы найдете обзор различных моделей нейросетей и примеры их использования для решения таких задач:

обнаружение объектов;
сегментация;
оценка позы;
классификация;
обнаружение масок на лицах людей;
обнаружение лиц;
отслеживание объектов;
определение положения головы;
обнаружение текста;
увеличение изображений без потери деталей;
раскрашивание черно-белых изображений;
реконструкция лица;
управление парковками

Исходные коды программ обнаружения

Далее мы приведем краткое описание исходных кодов некоторых программ обнаружения из репозитория ml-repka. Это программы facedetect-yn, facedetect, humandetect и humanseg.

Программа facedetect-yn

Ранее вы запускали программу обнаружения лиц следующей командой:

# make run-facedetect

При этом выполняется программа run-facedetect-yn. Эта программа использует быструю и точную сверточную сеть для обнаружения лиц YuNet. Для обнаружения лиц программа run-facedetect-yn использует предварительно обученную модель в формате ONNX (Open Neural Network Exchange).

Исходный текст программы run-facedetect-yn вы найдете в листинге 1. Для сокращения объема статьи мы не будем приводить и описывать его полностью.

Листинг 1. ml-repka/facedetect_yn/demo.cpp

В начале листинга подключаются заголовочные файлы OpenCV, а также стандартные библиотеки C++:

#include "opencv2/opencv.hpp"
#include <map>
#include <vector>
#include <string>
#include <iostream>

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

int device_id = parser.get<int>("device_id");
auto cap = cv::VideoCapture(device_id);
cap.setExceptionMode(true);
int w = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_WIDTH));
int h = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_HEIGHT));

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

YuNet model(model path, cv::Size(w, h), conf_threshold, nms_threshold, top_k, backend_id, target_id);

Путь к файлу обученной модели path передается программе через параметры запуска.

Метод setInputSize устанавливает размер входного изображения, которое будет использоваться моделью для обработки:

model.setInputSize(cv::Size(w, h));

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

Захват кадра выполняется методом cap.read:

bool has_frame = cap.read(frame);

Процедура предсказания (инференс) выполняется методом model.infer. При этом время выполнения инференса определяется методами tick_meter.start и tick_meter.stop:

tick_meter.start();
cv::Mat faces = model.infer(resized_frame);
tick_meter.stop();

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

for (int i = 0; i < faces.rows; ++i)
{
    faces.at<float>(i, 0) *= scale_x; // x1
    faces.at<float>(i, 1) *= scale_y; // y1
    faces.at<float>(i, 2) *= scale_x; // w
    faces.at<float>(i, 3) *= scale_y; // h
    for (int j = 0; j < 5; ++j)
    {
        faces.at<float>(i, 2*j+4) *= scale_x; // x для точек на лице
        faces.at<float>(i, 2*j+5) *= scale_y; // y для точек на лице
    }
}

Далее с помощью функции visualize результаты рисуются на исходном кадре, и этот кадр отображается в окне "image":

auto res_image = visualize(frame, faces, (float)tick_meter.getFPS());
if (frame.empty()) {
    continue;
}
cv::namedWindow("image", cv::WINDOW_NORMAL);
cv::imshow("image", res_image);

В конце цикла счетчик времени сбрасывается для измерений в следующем цикле обработки:

tick_meter.reset();

Программа facedetect

Если вы создаете программы на языке Golang, вам пригодится исходный код программы facedetect, который есть в репозитории ml-repka и представлен в листинге 2.

Листинг 2. ml-repka/facedetect/main.go

В самом начале программы импортируются стандартные библиотеки, а также библиотеки для работы с компьютерным зрением и машинным обучением:

import (
	"fmt"
	"gocv.io/x/gocv"
	"image"
	"image/color"
	"os"
	wrapper "rainbowsoft.ru/ml_wrapper"
	"strconv"
	"time"
)

Библиотека gocv.io/x/gocv представляет собой обертку для фреймворка OpenCV, предназначенного для обработки изображений и видео, а также для разработки приложений компьютерного зрения.

Библиотека rainbowsoft.ru/ml_wrapper — это внешняя библиотека с обертками для машинного обучения от rainbowsoft.ru, предоставляющая удобные методы для работы с моделями машинного обучения.

Остальные библиотеки — стандартные. Библиотека fmt содержит методы для форматированного вывода данных, image — для работы с изображениями, image/color — для работы с цветами изображений, os — для работы с ОС, в частности, с файлами, strconv — для преобразования строк в числа и чисел в строки, time — для работы со временем.

В первой строке функции main задается путь к файлу предварительно обученной модели каскада Хаара для обнаружения лиц на изображениях:

xmlFile := "facedetect/data/haarcascade_frontalface_default.xml"

Метод компьютерного зрения с названием каскад Хаара применяется для обнаружения объектов в изображениях или видео. Он базируется на простых признаках, таких как изменение интенсивности пикселей.

Упомянутый выше XML-файл является частью библиотеки OpenCV. В нем содержится информация о структуре и весах признаков, необходимых для обнаружения лиц. В процессе обнаружения лиц каскад Хаара сканирует изображение с помощью окна фиксированного размера, которое перемещается по изображению. На каждом шаге каскад проверяет, соответствует ли область признакам, описанным в XML-файле, и принимает решение о том, содержит ли она лицо или нет.

Программе передаются два параметра — источник видео и ограничения на количество фреймов в секунду (Frame Per Second, FPS). Значения этих параметров записываются в переменные deviceID и fixedFPS, соответственно:

deviceID := os.Args[1]
fixedFPS, err := strconv.Atoi(os.Args[2])

Когда вы запускаете программу командой «make run-facedetect», то эти параметры передаются через Makefile:

SOURCE ?= 1 # Источник видео (Файл, вебка)
FPS ?= 0 # Ограничение FPS (0 - без ограничения)

Экспериментируя с программой обнаружения лиц, вы можете менять эти параметры.

После сохранения параметров запуска программа создает объект захвата видео, обращаясь для этого к методам NewVideoCapture и VideoCaptureOpen библиотеки ml_wrapper:

video := wrapper.NewVideoCapture()
err = wrapper.VideoCaptureOpen(video, deviceID)
if err != nil {
	fmt.Println("Ошибка открытия видео потока:", err)
	return
}
defer wrapper.VideoCaptureClose(video)

Обратите внимание, что при создании объекта захвата видео используется переменная deviceID — идентификатор источника видео, заданный в первом параметре запуска программы.

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

На следующем шаге методом gocv.NewWindow создается окно для изображения с обнаруженными лицами. Также с помощью метода color.RGBA задается цвет рамки:

window := gocv.NewWindow("Face Detect")
defer window.Close()
blue := color.RGBA{0, 0, 255, 0}

Далее загружается XML-файл предварительно обученного классификатора обнаружения лиц методом каскадов Хаара:

classifier := gocv.NewCascadeClassifier()
defer classifier.Close()

if !classifier.Load(xmlFile) {
	fmt.Printf("Error reading cascade file: %v\n", xmlFile)
	return
}

Обработка потока видео выполняется в бесконечном цикле. Кадры считываются из видеопотока методом wrapper.VideoCaptureReadFrame:

empty, err := wrapper.VideoCaptureReadFrame(video)
if err != nil {
	fmt.Println(err)
	continue
}
if empty {
	continue
}

Обнаружение лиц выполняется методом DetectMultiScale с помощью загруженного классификатора:

rects := classifier.DetectMultiScale(*video.Img())

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

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

Если обнаружено лицо, выводится текст Human. Для объектов других классов выводятся названия соответствующих классов.

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

В конце тела цикла программа выводит изображение на экран и ожидает нажатия любой клавиши:

window.IMShow(*video.Img())
if window.WaitKey(1) >= 0 {
	break
}

Если нажать клавишу, работа цикла будет прервана.

Исходные тексты библиотеки с обертками wrapper вы найдете в каталоге /root/workspace/ml-repka/wrapper.

Для работы с видео и классификатором в этой библиотеке используются соответствующие методы обертки gocv.io/x/gocv над фреймворком OpenCV.

Программа humandetect

Программа humandetect использует модель YoloFastestV2 и фреймворк OpenCV. Она составлена на языке программирования C++ (листинг 3). Для сокращения объема статьи полный исходный текст этой программы не приводится.

Листинг 3. ml-repka/humandetect_ncnn_yolofastest_v2/main.cpp

В начале программы определены заголовочные файлы:

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <stdio.h>
#include <vector>
#include "yolo-fastestv2.h"

Здесь подключаются заголовочные файлы библиотеки OpenCV, предназначенные для работы с изображениями и видео, заголовочный файл для YOLO, а также заголовочные файлы для работы с потоками ввода-вывода, с функциями для работы с файлами и шаблонный класс динамического массива в стандартной библиотеке C++.

Назначение заголовочных файлов библиотеки OpenCV:

opencv2/core/core.hpp — основные структуры данных и функции для работы с матрицами, изображениями и массивами в OpenCV;
opencv2/highgui/highgui.hpp — функции для показа изображений на экране и управления окнами в OpenCV;
opencv2/imgproc/imgproc.hpp —функции для обработки изображений, такие как фильтрация, преобразование цветовых пространств и обнаружение краев

Документацию на модули OpenCV версии 4.9.0, включая перечисленные выше функции, можно найти здесь.

Для работы с моделью YoloFastestV2 в репозитории ml-repka имеются файлы yolo-fastestv2.cpp (листинг 4) и yolo-fastestv2.h (листинг 5).

Листинг 4. ml-repka/humandetect_ncnn_yolofastest_v2/yolo-fastestv2.cpp

Листинг 5. ml-repka/humandetect_ncnn_yolofastest_v2 yolo-fastestv2.h

В переменной yoloF2 определен объект класса yoloFastestv2:

yoloFastestv2 yoloF2;

При запуске функция main программы humandetect получает два параметра — идентификатор камеры cam_id и количество потоков выполнения num_threads:

int cam_id = atoi(argv[1]);
int num_threads = atoi(argv[2]);

Объект yoloF2 инициализируется следующим образом:

yoloF2.init(false, num_threads); //we have no GPU

После инициализации загружаются файлы предварительно обученной модели:

yoloF2.loadModel("data/yolo-fastestv2-opt.param","data/yolo-fastestv2-opt.bin");

Далее запускается захват видео с камеры при помощи OpenCV:

cv::VideoCapture cap(cam_id);

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

while(1){
     cap >> frame;
	…
     std::vector<TargetBox> boxes;
     yoloF2.detection(frame, boxes);
     draw_objects(frame, boxes);
…
     int baseLine = 0;
     cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.6, 1.5, &baseLine);
     cv::rectangle(frame, cv::Rect(cv::Point(0, 0), cv::Size(label_size.width + 20, label_size.height + 15)), cv::Scalar(0, 0, 0), -1);
     putText(frame, text, cv::Point(10, 20), cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(0, 255, 0), 1.5);

     if (frame.empty()) {
         continue;
     }
     cv::namedWindow("image", cv::WINDOW_NORMAL);
     cv::imshow("image", frame);
…
     char esc = cv::waitKey(5);
     if(esc == 27) break;
}

Цикл будет работать до тех пор, пока пользователь не нажмет какую-нибудь кнопку.

Файлы обученной модели YoloFastestV2 есть в репозитории ml-repka, но их можно скачать и здесь.

Программа сегментации humanseg

Исходный код сегментации людей humanseg вы найдете в листинге 6.

Листинг 6. ml-repka/humanseg/demo.cpp

Эта программа реализует приложение для сегментации людей в видеопотоке или видеофайле с использованием модели сегментации.

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

string modelPath = parser.get<string>("model");

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

PPHS humanSegmentationModel(modelPath, backend_target_pairs[backendTarget].first, backend_target_pairs[backendTarget].second);

Параметры бэкенда определяют, какой движок будет использоваться для выполнения операций инференса (предсказаний) модели. Задавая эти параметры, можно выбрать, где будут выполняться вычисления — на CPU, GPU или на других специализированных аппаратных ускорителях.

После инициализации модели сегментации программа открывает видео поток:

cap.open(samples::findFile(inputPath));

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

Захват кадра выполняет следующий код:

cap >> frame;

Инференс модели запускается с изменением времени его выполнения:

tm.start();
result = humanSegmentationModel.infer(frame);
tm.stop();

И, наконец, выполняется визуализация и отображение результата:

Mat res_frame = visualize(frame, result, tm.getFPS());
…
imshow(kWinName, res_frame);

Для завершения цикла нужно нажать любую клавишу в окне отображения.

Полезные ссылки

Итоги

В этом материале рассмотрено, как устроены «живые» нейроны и как их моделируют с помощью компьютеров и компьютерных нейронных сетей, познакомились с перцептроном, сверточными сетями, с алгоритмом YOLO и каскадами Хаара.

В практическом плане рассмотрели с пошаговой инструкцией и собрали на базе микрокомпьютера Repka Pi и веб-камеры, подключенной через USB, полноценную систему распознавания. Установили на неё операционную систему Repka OS, компилятор для языка Golang, библиотеки OpenCV, NCNN и программы из репозитория ml-repka, затем провели сборку фреймворка, предназначенного для работы с нейросетями и запустили и проверили в работе демонстрационные программы из состава репозитория ml-repka.

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

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

Успехов Вам в Ваших проектах и творческой деятельности!