Аппаратные наборы

Развёртывание машинного обучения на реальном встраиваемом оборудовании. Платы стоят от $25, а если бюджета нет, интерактивные лабораторные работы воспроизводят весь опыт работы с оборудованием в симуляции.

Эти практические лабораторные работы сопровождают учебник Machine Learning Systems и переносят теорию на настоящее оборудование. Вы развернёте модели машинного обучения на встраиваемых устройствах, которые помещаются в ладони: от классификации изображений до распознавания голоса и обнаружения движения. Профессиональные отладочные платы стоимостью $25–100 дают мгновенную ощутимую обратную связь: когда модель работает успешно, светодиоды загораются, моторы вращаются, а зуммеры звучат.

Работа в условиях ограниченных ресурсов встраиваемых устройств (обычно 2 МБ оперативной памяти и 1 МБ флеш-памяти) заставляет сталкиваться с теми же инженерными компромиссами, которые определяют крупномасштабные ML-системы, но в осязаемой среде, где каждое решение по оптимизации сразу даёт наблюдаемый результат.

Разработка лабораторных работ. Эти практические лабораторные работы разработаны совместно проф. Vijay Janapa Reddi и Marcelo Rovai; разработкой руководил Marcelo. Его многолетний опыт в области встраиваемых систем позволил создать доступные практические занятия, которые связывают теорию с реальной реализацией.

Marcelo также написал открытые книги-компаньоны о платах Nicla Vision, XIAO и Raspberry Pi. Прямые ссылки и описания см. в разделе «Companion Books» Хаба для преподавателей.

Аппаратные платформы

• Grove Vision AI V2, ~$25. Лучший выбор для начинающих: готовое решение для компьютерного зрения «подключи и работай».
• XIAOML Kit, ~$40. Лучшее соотношение цены и возможностей: зрение, звук и движение.
• Raspberry Pi, ~$60–80. Продвинутые проекты: LLM, VLM и периферийный ИИ.
• Nicla Vision, ~$95. Профессиональный уровень и два датчика в компактном корпусе.

Что вы создадите

• Компьютерное зрение. Классификация изображений и обнаружение объектов на микроконтроллерах. Обучайте модели распознавать объекты, находить лица или классифицировать сцены, а затем запускайте их на устройствах, работающих от батареи.
• Обработка звука. Распознавание ключевых слов и голосовых команд. Создавайте детекторы слова пробуждения и простые голосовые интерфейсы, которые работают полностью на устройстве, без облака.
• Классификация движения. Распознавание активности и жестов по данным IMU. Создавайте носимые приложения, которые определяют ходьбу, бег или пользовательские жесты с помощью акселерометра и гироскопа.
• Большие языковые модели. Запускайте LLM и VLM на периферийных устройствах. Познакомьтесь с передовыми возможностями ИИ на устройстве: модели понимают и генерируют текст.

Начало работы

1. Выберите оборудование. Подберите платформу по бюджету и учебным целям. Подробное сравнение см. в разделе «Платформы».
2. Настройте среду. Установите Arduino IDE или инструменты для конкретной платформы. Пошаговые инструкции см. в руководстве по настройке среды разработки.
3. Соберите и разверните. Выполняйте лабораторные работы для выбранной платформы. Начните с раздела «Начало работы», где описаны все доступные упражнения.

Часть экосистемы MLSysBook

• Учебник — полная теория по всему стеку систем машинного обучения.
• Слайды лекций — презентации Beamer и учебные материалы для каждой главы.
• Лабораторные работы — интерактивные блокноты Marimo, которые проверяют утверждения книги.
• Аппаратные наборы — практическое развёртывание машинного обучения на реальных встраиваемых устройствах.
• Хаб для преподавателей — карты курсов, учебные программы и материалы для внедрения курса в преподавание.
• TinyTorch — постройте собственный фреймворк машинного обучения с нуля, модуль за модулем.
• MLSys·im — аналитический движок моделирования, на котором основаны количественные рисунки книги.

Начало работы

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

Шаг 1. Выберите платформу

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

Для начинающих и тех, кто ограничен в бюджете:

Для продвинутых приложений:

Подробные характеристики и технические сравнения см. на странице «Платформы».

Шаг 2. Настройте среду разработки

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

Ориентировочное время: 30–60 минут в зависимости от платформы и скорости интернета.

Полные инструкции см. в руководстве по настройке среды разработки. В нём описаны:

• требования к компьютеру для разработки;
• установка Arduino IDE для платформ на микроконтроллерах;
• настройка среды Python для Raspberry Pi;
• веб-интерфейс SenseCraft AI для Grove Vision AI V2;
• настройка последовательной связи (Serial) и проверка оборудования.

Шаг 3. Выберите первую лабораторную работу

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

Доступность упражнений по платформам

Шаг 4. Начните первую лабораторную работу

Grove Vision AI V2: начните с раздела «Настройка и приложения без кода». Вы развернёте предобученную модель за несколько минут в визуальном интерфейсе.

XIAOML Kit: начните с раздела «Настройка», затем перейдите к разделу «Классификация изображений», чтобы обучить и развернуть свою первую модель.

Nicla Vision: пройдите «Настройку», чтобы подготовить плату, и попробуйте «Классификацию изображений».

Raspberry Pi: выполните «Настройку», затем выберите путь:

• «Классификация изображений» — основы компьютерного зрения;
• «Развёртывание LLM» — запуск языковых моделей на периферийных устройствах.

Предварительные требования

Лабораторные работы рассчитаны на следующую подготовку:

• Программирование: уверенное владение Python. Знание C/C++ полезно для платформ на микроконтроллерах, но не обязательно.
• Математика: рабочее знание линейной алгебры и основ теории вероятностей на уровне бакалавриата.
• Оборудование: опыт работы со встраиваемыми системами не нужен. Каждая лабораторная работа содержит полные инструкции по настройке и поиску неисправностей.

Связь с учебником «Machine Learning Systems»

Эти лабораторные работы дополняют отдельные главы учебника «Machine Learning Systems»:

• Лабораторные работы по классификации изображений закрепляют материал глав о компьютерном зрении и оптимизации моделей;
• Лабораторные работы по распознаванию ключевых слов связаны с главами об обработке аудио и инференсе в реальном времени;
• Лабораторные работы по классификации движения демонстрируют слияние данных датчиков и анализ временных рядов;
• Лабораторные работы по LLM и VLM переносят развёртывание больших моделей в среду с ограниченными ресурсами.

Каждая лабораторная работа указывает соответствующие разделы учебника для более глубокого теоретического изучения.

Настройка среды разработки

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

Настройка среды обычно занимает 30–60 минут в зависимости от выбранной платформы и скорости интернета. Эти процедуры рассчитаны на студентов, у которых нет опыта работы со встраиваемыми системами.

Системные требования

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

Компьютер для разработки:

• Операционная система: Windows 10/11, macOS 10.15+ или Linux (Ubuntu 18.04+)
• Память: минимум 8 ГБ ОЗУ (для разработки на Raspberry Pi рекомендуется 16 ГБ)
• Накопитель: 10 ГБ свободного места для инструментов разработки и библиотек
• Порты USB: хотя бы один порт USB 2.0/3.0 для подключения устройства
• Интернет: необходим для установки программ и загрузки библиотек

Программные требования:

• Arduino IDE 2.0+ для платформ на базе Arduino (XIAO, Nicla Vision)
• Python 3.8+ для разработки на Raspberry Pi
• Git для управления версиями и доступа к примерам кода
• Текстовый редактор или IDE, например VS Code или PyCharm

Аксессуары для оборудования:

• USB-кабели: USB-C или Micro-USB (кабель должен передавать данные, а не только питание)
• SD-карта: 32 ГБ и больше, класс 10, для Raspberry Pi
• Блоки питания: подходящие для каждой платформы
• Модули камеры: входят в состав большинства наборов или продаются отдельно

Установка программного обеспечения для конкретных платформ

Каждая аппаратная платформа требует собственного подхода к разработке, который отражает практику реальной встраиваемой инженерии. Системы на базе Arduino сосредоточены на эффективном использовании ресурсов и ограничениях реального времени, Raspberry Pi демонстрирует полноценные возможности периферийных вычислений, а специализированное ИИ-оборудование показывает методы аппаратного ускорения.

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

Платформы на базе Arduino (Nicla Vision, XIAOML Kit)

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

Установка Arduino IDE:

1. Скачайте Arduino IDE 2.0 с сайта arduino.cc/software
2. Установите программу, следуя мастеру установки для вашей платформы
3. Запустите Arduino IDE и откройте меню File → Preferences (Файл → Настройки)
4. Добавьте ссылки на пакеты поддержки плат:
   • для XIAOML Kit: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
   • для Nicla Vision: ссылка указана в Boards Manager (менеджере плат) Arduino IDE

Установка пакетов поддержки плат:

1. Откройте Tools → Board → Boards Manager (Инструменты → Плата → Менеджер плат)
2. Найдите свою платформу:
   • XIAOML Kit: введите «ESP32» и установите «esp32 by Espressif Systems»
   • Nicla Vision: введите «Arduino Mbed OS Nicla Boards» и установите пакет
3. Выберите свою плату в меню Tools → Board (Инструменты → Плата)
4. Установите нужные библиотеки через Library Manager (менеджер библиотек)

Основные библиотеки:

• TensorFlow Lite Micro
• драйверы камер для конкретной платы
• библиотеки интерфейсов датчиков (I2C, SPI)

Платформа Grove Vision AI V2

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

Настройка SenseCraft AI:

1. Создайте учётную запись на сайте sensecraft.seeed.cc
2. Подключите Grove Vision AI V2 через USB
3. Откройте устройство в веб-интерфейсе SenseCraft AI
4. Для визуального программирования локальная установка программ не требуется

Настройка Arduino IDE (для собственной разработки):

Следуйте инструкциям для платформ на базе Arduino, описанным выше, и используйте в менеджере плат ссылку на пакет Seeed Studio.

Платформа Raspberry Pi

Среда Raspberry Pi соединяет ограничения встраиваемых систем с полноценными вычислительными возможностями: студенты знакомятся и с оптимизацией ресурсов, и с продвинутыми ML-фреймворками. Такой двойной взгляд показывает, как вычислительные ресурсы влияют на выбор алгоритмов и архитектуру системы.

Установка операционной системы:

1. Скачайте Raspberry Pi Imager
2. Запишите Raspberry Pi OS (рекомендуется 64-разрядная версия) на microSD-карту объёмом не меньше 32 ГБ
3. Во время записи настройте доступ по SSH и учётные данные Wi-Fi
4. Вставьте записанную SD-карту и включите Raspberry Pi

Настройка программной среды:

Следующие команды создают полноценную среду разработки ML на Python с правильным управлением зависимостями:

# Обновление системных пакетов
sudo apt update && sudo apt upgrade -y

# Установка инструментов разработки Python
# python3-pip: установщик пакетов Python
# python3-venv: создание виртуальных окружений
# python3-dev: заголовочные файлы для разработки на Python
sudo apt install python3-pip \
                 python3-venv \
                 python3-dev -y

# Установка зависимостей ML-фреймворков
# libatlas-base-dev: библиотека линейной алгебры (BLAS/LAPACK)
# libhdf5-dev: библиотека формата данных HDF5
# libhdf5-serial-dev: последовательная версия HDF5
sudo apt install libatlas-base-dev \
                 libhdf5-dev \
                 libhdf5-serial-dev -y

# Установка зависимостей компьютерного зрения
# libcamera-dev: библиотека интерфейса камеры
# python3-libcamera: привязки Python для libcamera
# python3-kms++: библиотека установки режима ядра (kernel mode setting)
sudo apt install libcamera-dev \
                 python3-libcamera \
                 python3-kms++ -y

# Создание виртуального окружения для проектов
python3 -m venv ~/ml_projects
source ~/ml_projects/bin/activate

# Установка основных пакетов ML
# tensorflow: основной фреймворк ML
# tensorflow-lite: оптимизирован для периферийных и мобильных устройств
# opencv-python: библиотека компьютерного зрения
# numpy: основа численных вычислений
pip install tensorflow \
            tensorflow-lite \
            opencv-python \
            numpy

Настройка инструментов разработки

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

Настройка последовательной связи (Serial)

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

Windows:

• установите подходящие драйверы USB-to-serial (CH340, FTDI или драйверы конкретной платы);
• проверьте в диспетчере устройств, что плата распознаётся.

macOS/Linux:

• большинство адаптеров USB-to-serial работают без дополнительных драйверов;
• проверить распознавание устройства можно командой ls /dev/tty* (macOS/Linux);
• добавьте пользователя в группу dialout: sudo usermod -a -G dialout $USER (Linux).

Настройка IDE

Параметры среды разработки напрямую влияют на эффективность цикла «написать — проверить — развернуть», который характерен для разработки встраиваемых систем. Правильная настройка сокращает время отладки и даёт ясную обратную связь о производительности системы.

Параметры Arduino IDE:

• выберите нужный COM-порт в меню Tools → Port (Инструменты → Порт);
• задайте правильную плату и процессор;
• проверьте скорость загрузки (обычно 115200 бод);
• включите подробный вывод при компиляции для отладки.

Разработка на Raspberry Pi:

• настройте SSH-ключи для удалённой разработки;
• установите VS Code с расширениями Python и Remote SSH;
• настройте доступ к Jupyter Notebook для интерактивной работы.

Проверка среды

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

Тесты распознавания оборудования

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

Платформы Arduino:

void setup() {
  // Запуск последовательного порта на скорости 115200 бод
  Serial.begin(115200);
  Serial.println("Development environment test");
  Serial.print("Board: ");
  Serial.println(ARDUINO_BOARD);
}

void loop() {
  Serial.println("Environment operational");
  delay(1000);
}

Raspberry Pi:

# Проверка интерфейса камеры
libcamera-hello --timeout 5000

# Проверка среды ML на Python
python3 -c \
  "import tensorflow as tf; print('TensorFlow:', tf.__version__)"
python3 -c \
  "import cv2; print('OpenCV:', cv2.__version__)"

Grove Vision AI V2:

• проверьте, что устройство видно в веб-интерфейсе SenseCraft AI;
• протестируйте базовое развёртывание модели через визуальный интерфейс программирования.

Типичные проблемы при настройке и их решения

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

Проблемы с подключением устройства:

• убедитесь, что USB-кабель передаёт данные, а не только питание;
• установите драйверы USB для платформы, если устройство не распознаётся;
• попробуйте другие порты USB или USB-хаб, если соединение нестабильно.

Ошибки компиляции:

• проверьте, что в IDE выбраны правильная плата и процессор;
• убедитесь, что все нужные библиотеки установлены в совместимых версиях;
• проверьте, достаточно ли места на диске для компиляции.

Ошибки во время работы:

• убедитесь, что блок питания достаточно мощный (особенно для работы камеры);
• проверьте совместимость и формат SD-карты (Raspberry Pi);
• проверьте распределение памяти под ML-модели в рамках ограничений платформы.

Сетевое подключение (платформы с Wi-Fi):

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

Поиск и устранение неисправностей

Типичные аппаратные проблемы:

• Устройство не распознаётся: убедитесь, что USB-кабель передаёт данные, попробуйте другие порты;
• Ошибки загрузки: проверьте выбор платы и настройки порта в IDE;
• Проблемы с питанием: проверьте достаточность питания, особенно для работы камеры;
• Ошибки памяти: убедитесь, что модель укладывается в ограничения платформы.

Программные проблемы:

• Конфликты библиотек: используйте совместимые версии, указанные в руководствах по настройке;
• Ошибки компиляции: проверьте, что все зависимости установлены правильно;
• Сетевое подключение: проверьте настройки брандмауэра и разрешения сети.

Ресурсы для конкретных платформ:

• XIAOML Kit: документация Seeed Studio
  • документация по серии XIAO ESP32S3
• Arduino Nicla Vision: документация Arduino
• Grove Vision AI V2: платформа SenseCraft AI
• Raspberry Pi: официальная документация

Поддержка сообщества:

• GitHub Issues: сообщайте об ошибках и предлагайте функции через репозиторий проекта;
• Форумы: сообщества конкретных платформ на сайтах Arduino, Raspberry Pi и Seeed Studio;
• Stack Overflow: задавайте вопросы с тегами соответствующих платформ.

Готовность к лабораторным работам

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

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

Рекомендуемая последовательность:

1. Начните с простых упражнений на датчики, чтобы проверить работу оборудования.
2. Перейдите к приложениям ML с одним типом данных (изображения или звук).
3. Затем переходите к мультимодальным упражнениям и задачам оптимизации.

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

Платформы

Примечание о переводе. Цены указаны в долларах США, как в оригинале, и ориентировочны: перед покупкой проверьте актуальную стоимость у продавца.

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

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

Платформа в центре внимания

Полный комплект XIAOML Kit со всеми компонентами

XIAOML Kit — самая новая из наших учебных аппаратных платформ (выпущена 31 июля 2025 года). Это полноценная среда разработки TinyML для изучения ML-систем: встроенная беспроводная связь, камера, несколько датчиков и обширная документация. Эта компактная плата показывает, как современные встраиваемые системы могут эффективно обеспечивать продвинутые возможности машинного обучения в недорогом исполнении.

Обзор платформ

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

Стратегия выбора платформ

Сравнение платформ

В таблице ниже приведено подробное техническое сравнение всех четырёх платформ.

Матрица сравнения платформ

Рекомендации по выбору платформы

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

Матрица возможностей платформ

Технические характеристики платформ

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

XIAOML Kit (Seeed Studio)

Лучше всего для: IoT и беспроводного ML. XIAOML Kit хорошо справляется с беспроводной связью и проектами с ограниченным бюджетом. Он идеально подходит для изучения сетей IoT-датчиков, систем удалённого мониторинга и беспроводного ML-инференса, когда нужна надёжная связь в компактном и недорогом исполнении.

XIAOML Kit объединяет плату XIAO ESP32S3 Sense и плату расширения, образуя полноценную среду разработки TinyML. Одна только XIAO ESP32S3 Sense обеспечивает камеру и микрофон (зрение и звук), а плата расширения добавляет 6-осевой инерциальный измерительный блок (IMU) для классификации движения. Название «XIAO» (小) в переводе с китайского означает «крошечный» и отражает форм-фактор платы: $21\times 17,5$ мм.

XIAOML Kit с платой расширения

Архитектура процессора: Двухъядерный ESP32-S3 с ядрами Xtensa LX7 на частоте 240 МГц

Иерархия памяти: 8 МБ PSRAM и 8 МБ флеш-памяти

Связь: Wi-Fi 802.11 b/g/n и Bluetooth 5.0

Встроенные датчики:

• XIAO ESP32S3 Sense: камера OV2640, цифровой микрофон
• Плата расширения: 6-осевой инерциальный измерительный блок (IMU), 0,42-дюймовый OLED-дисплей

Характеристики питания: Питание 3,3 В с несколькими режимами пониженного энергопотребления

Среда разработки: Поддерживаются Arduino IDE и PlatformIO, есть обширная экосистема библиотек. Программирование ведётся на C/C++ с абстракциями в стиле Arduino; опытные пользователи могут работать напрямую с ESP-IDF.

Область применения: Сети IoT-датчиков, системы удалённого мониторинга, беспроводный ML-инференс, проекты с ограниченным бюджетом

Arduino Nicla Vision

Лучше всего для: проектирования со сверхнизким энергопотреблением. Arduino Nicla Vision оптимизирована для устройств с питанием от батареи и систем непрерывного сенсорного наблюдения. Она идеально подходит для изучения проектирования со сверхнизким энергопотреблением, систем классификации изображений и обнаружения объектов, где время работы от батареи измеряется месяцами, а не часами.

Nicla Vision — пример профессиональных встраиваемых систем технического зрения, построенных на микроконтроллере STM32H7. Эта платформа показывает, как специализированная аппаратная архитектура позволяет выполнять сложный ML-инференс в жёстких ограничениях ресурсов.

Arduino Nicla Vision с модулем камеры

Архитектура процессора: Двухъядерный STM32H747: ARM Cortex-M7 и Cortex-M4 на частоте 480 МГц

Иерархия памяти: 1 МБ встроенной SRAM и 2 МБ флеш-памяти, а также 16 МБ внешней QSPI-флеш-памяти

Встроенные датчики: Камера GC2145, цифровой микрофон MP34DT05, 6-осевой IMU

Характеристики питания: Питание 3,3 В, оптимизированное для работы от батареи

Среда разработки: Поддерживаются Arduino IDE и OpenMV IDE со специализированными библиотеками компьютерного зрения. Для быстрого прототипирования доступен MicroPython, а для промышленного развёртывания — C/C++.

Область применения: Устройства с питанием от батареи, системы классификации изображений, обнаружение объектов, непрерывное сенсорное наблюдение

Grove Vision AI V2

Лучше всего для: аппаратного ускорения. Grove Vision AI V2 содержит специализированный аппаратный блок для нейронных сетей, благодаря которому производительность растёт на порядки. Плата идеально подходит для изучения систем промышленного контроля, аналитики видео в реальном времени и продвинутого обнаружения объектов, где нужен инференс с ускорением на NPU.

Grove Vision AI V2 включает выделенный блок нейронной обработки (NPU), который демонстрирует аппаратно ускоренный ML-инференс. Эта платформа показывает, как специализированные ИИ-процессоры дают прирост производительности на порядки по сравнению с реализациями, работающими только программно.

Grove Vision AI V2 с NPU

Архитектура процессора: ARM Cortex-M55 со встроенным NPU Ethos-U55

Иерархия памяти: 16 МБ внешней памяти для хранения модели и данных

Нейропроцессорный блок: Выделенный аппаратный ускоритель для ML-инференса

Интерфейс камеры: Стандартный разъём CSI, поддерживающий различные модули камер

Аудиовход: Встроенный цифровой микрофон

Среда разработки: Визуальная платформа программирования SenseCraft AI для разработки без написания кода, а также поддержка Arduino IDE для собственных приложений. Доступны как графическое программирование, так и традиционная разработка на C/C++.

Область применения: Системы промышленного контроля, аналитика видео в реальном времени, продвинутое обнаружение объектов, инференс с ускорением на NPU

Raspberry Pi (модели 4/5 и Zero 2W)

Лучше всего для: полноценных ML-фреймворков. Raspberry Pi соединяет встраиваемые системы и традиционные вычисления, предоставляя полноценную среду Linux для продвинутых ML-приложений. Она идеальна для изучения периферийных ИИ-шлюзов, сложных систем компьютерного зрения, развёртывания языковых моделей и мультимодальных ИИ-приложений, где нужны полные вычислительные возможности.

Семейство Raspberry Pi соединяет встраиваемые системы и традиционные вычисления: оно даёт полноценную среду Linux и при этом остаётся доступным для обучения. Эта платформа показывает, как увеличение вычислительных ресурсов открывает путь к сложным ML-приложениям.

Raspberry Pi 5 и Pi Zero 2W для сравнения

Архитектура процессора: ARM Cortex-A76 (Pi 5) или Cortex-A53 (Zero 2W)

Иерархия памяти: Оперативная память DDR4 объёмом 1–16 ГБ в зависимости от модели

Накопитель: Основное хранилище — microSD-карта, расширение через USB 3.0

Связь: Gigabit Ethernet, Wi-Fi, Bluetooth, несколько портов USB

Интерфейс камеры: Выделенный разъём CSI и поддержка USB-камер

Операционная система: Raspberry Pi OS на основе Debian (полноценный дистрибутив Linux)

Среда разработки: Полноценная среда разработки Linux с нативной поддержкой Python, C/C++ и JavaScript. Менеджеры пакетов (apt, pip) дают доступ к обширному набору ML-библиотек, включая TensorFlow, PyTorch и OpenCV.

Область применения: Периферийные ИИ-шлюзы, системы компьютерного зрения, развёртывание языковых моделей, мультимодальные ИИ-приложения

Начало работы

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

• Seeed Studio — XIAOML Kit и модуль Grove Vision AI V2
• Магазин Arduino — Nicla Vision
• Raspberry Pi Foundation — платы и наборы
• DigiKey, Mouser, SparkFun — альтернативные дистрибьюторы с широким ассортиментом компонентов и наборов

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

Обзор

Эти лабораторные работы дают уникальную возможность получить практический опыт работы с системами машинного обучения (ML). В отличие от работы с большими моделями, которым нужны ресурсы уровня дата-центра, эти упражнения позволяют напрямую работать с оборудованием и программным обеспечением с помощью TinyML. Такой практический подход даёт осязаемое понимание проблем и возможностей развёртывания ИИ, пусть и в крошечном масштабе. При этом принципы в целом те же, что и при работе с более крупными системами.

Nicla Vision. Источник: Arduino.

Где купить

Arduino Nicla Vision можно купить в официальном магазине Arduino:

• Arduino Store (~$95)

Предварительные требования

• Плата Nicla Vision: убедитесь, что плата у вас есть.
• USB-кабель: для подключения платы к компьютеру.
• Сеть: доступ в интернет для загрузки необходимого программного обеспечения.

Настройка

• Настройка Nicla Vision

Упражнения

Классификация изображений

Промпт DALL·E 3: мультфильм в стиле 1950-х с компактным электронным устройством и модулем камеры на деревянном столе. На экране слева синие роботы, справа зелёные периквито. Светодиоды на устройстве показывают классы, а персонажи в ретро-одежде с интересом наблюдают.

Обзор

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

Всё чаще мы сталкиваемся с революцией в области искусственного интеллекта, где, как отмечает Gartner, Edge AI имеет очень большой потенциал влияния, и это уже сейчас!

В «яблочке» радара находится периферийное компьютерное зрение (Edge Computer Vision). Когда речь заходит о машинном обучении (ML) применительно к зрению, в первую очередь приходит на ум классификация изображений — своего рода «Hello World» для ML!

В этой лабораторной работе мы разберём проект компьютерного зрения, который использует свёрточные нейронные сети (CNN) для классификации изображений в реальном времени. Опираясь на экосистему TensorFlow, мы возьмём предобученную модель MobileNet и адаптируем её для развёртывания на периферийном устройстве. Основное внимание будет уделено оптимизации модели, чтобы она эффективно работала на аппаратном обеспечении с ограниченными ресурсами и при этом не теряла точности.

Мы применим такие приёмы, как квантизация и прунинг (удаление избыточных весов), чтобы снизить вычислительную нагрузку. К концу руководства у вас будет работающий прототип, который классифицирует изображения в реальном времени и работает на маломощной встраиваемой системе на базе платы Arduino Nicla Vision.

Компьютерное зрение

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

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

Обе модели можно реализовать на крошечных устройствах вроде Arduino Nicla Vision и использовать в реальных проектах. В этой главе мы разберём классификацию изображений.

Цель проекта классификации изображений

Первый шаг любого проекта ML — определить цель. В данном случае цель — обнаружить и классифицировать два конкретных объекта, присутствующих на одном изображении. Для проекта мы возьмём две небольшие игрушки: робота и маленького бразильского попугая (по имени Periquito). Также мы соберём изображения фона, на которых этих двух объектов нет.

Сбор данных

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

• инструмент Web Serial Camera;
• Edge Impulse Studio;
• OpenMV IDE;
• смартфон.

Здесь мы будем использовать OpenMV IDE.

Сбор набора данных в OpenMV IDE

Сначала создадим на компьютере папку, в которую будут сохраняться данные, например «data». Затем в OpenMV IDE откроем Tools > Dataset Editor и выберем New Dataset, чтобы начать сбор набора данных:

IDE попросит открыть файл, в который будут сохраняться данные. Выберите созданную папку «data». Обратите внимание: на левой панели появятся новые значки.

Используя верхний значок (1), введите имя первого класса, например «periquito»:

Запустите скрипт dataset_capture_script.py и нажмите значок камеры (2), чтобы начать съёмку изображений:

Повторите ту же процедуру для остальных классов.

Рекомендуем около 50–60 изображений для каждой категории. Старайтесь снимать с разных ракурсов, на разном фоне и при разном освещении.

Сохраняемые изображения имеют размер кадра QVGA $320\times 240$ и формат цвета RGB565 (формат цветных пикселей).

Когда набор данных собран, закройте инструмент Dataset Editor через Tools > Dataset Editor.

В итоге на компьютере появится набор данных с тремя классами: periquito, robot и background.

Теперь вернитесь в Edge Impulse Studio и загрузите набор данных в созданный проект.

Обучение модели в Edge Impulse Studio

Для обучения модели мы воспользуемся Edge Impulse Studio. Войдите в аккаунт и создайте новый проект:

Здесь можно клонировать похожий проект: NICLA-Vision_Image_Classification.

Набор данных

Работая в EI Studio (или просто Studio), мы пройдём четыре основных шага, чтобы подготовить модель к использованию на плате Nicla Vision: Dataset (набор данных), Impulse (конвейер), Tests (тесты) и Deploy (развёртывание на периферийном устройстве, в данном случае на NiclaV).

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

EI Studio сам отберёт часть обучающих данных для валидации.

В Studio откройте вкладку Data acquisition, а в разделе UPLOAD DATA загрузите файлы выбранных категорий с компьютера:

Разделение исходного набора на обучающую и тестовую выборки оставьте Studio и выберите метку для этих данных:

Повторите процедуру для всех трёх классов.

Можно выбрать папку и загрузить все файлы сразу.

В итоге в Studio должны появиться ваши «сырые данные» (raw data):

Обратите внимание: при начале загрузки может появиться всплывающее окно с вопросом, создаёте ли вы проект обнаружения объектов (Object Detection). Выберите [NO].

Тип проекта всегда можно изменить в разделе Dashboard: One label per data item (классификация изображений):

При желании Studio позволяет просмотреть все данные проекта целиком. Можно очищать, проверять или менять метки, щёлкая по отдельным элементам. В нашем случае данные выглядят корректно.

Проектирование Impulse

На этом этапе нужно определить, как:

• предобработать данные: изменить размер отдельных изображений и выбрать color depth (RGB или оттенки серого);
• задать модель: в данном случае это Transfer Learning (Images) — дообучение предобученной модели классификации изображений MobileNet V2 на наших данных. Этот метод хорошо работает даже с небольшими наборами изображений (в нашем случае около 150 изображений).

Перенос обучения (Transfer Learning) с MobileNet упрощает обучение модели. Это особенно полезно в условиях ограниченных ресурсов и при малом количестве размеченных данных. MobileNet, известная своей лёгкой архитектурой, — предобученная модель, которая уже выучила полезные признаки на большом наборе данных (ImageNet).

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

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

Перейдите на вкладку Impulse Design и создайте impulse, задав размер изображения $96\times 96$ и сжатие к квадратной форме (без обрезки). Выберите блоки Image и Transfer Learning. Сохраните Impulse.

Предобработка изображений

Все входные изображения QVGA/RGB565 будут преобразованы в 27 648 признаков ($96\times 96\times 3$).

Нажмите [Save parameters] и сгенерируйте все признаки:

Проектирование модели

В 2017 году Google представил MobileNetV1 — семейство универсальных нейронных сетей для компьютерного зрения, созданных с расчётом на мобильные устройства и поддерживающих классификацию, обнаружение и другие задачи. MobileNet — компактные модели с малой задержкой и низким энергопотреблением, параметры которых подобраны под ресурсные ограничения разных сценариев. В 2018 году Google выпустил MobileNetV2: Inverted Residuals and Linear Bottlenecks.

MobileNet V1 и MobileNet V2 ориентированы на эффективность в мобильных устройствах и во встраиваемом зрении, но различаются по сложности архитектуры и производительности. Обе используют разделяемые по глубине свёртки (depthwise separable convolutions), чтобы снизить вычислительные затраты, однако MobileNet V2 вводит инвертированные остаточные блоки (Inverted Residual Blocks) и линейные бутылочные горлышки (Linear Bottlenecks), чтобы повысить производительность. Эти новшества позволяют V2 выделять более сложные признаки меньшим количеством параметров, поэтому она вычислительно эффективнее и, как правило, точнее предшественницы. Кроме того, V2 использует нелинейную активацию в промежуточном слое расширения, а для слоя бутылочного горлышка по-прежнему применяет линейную активацию: такое решение, как показали исследования, помогает сохранять важную информацию по всей сети. MobileNet V2 предлагает оптимизированную архитектуру с более высокой точностью и эффективностью, её мы и будем использовать в проекте.

Хотя базовая архитектура MobileNet уже компактна и быстра, в некоторых задачах модель должна быть ещё меньше и быстрее. MobileNet вводит простой параметр $\alpha$ (альфа) — множитель ширины (width multiplier), с помощью которого строятся меньшие и менее требовательные к вычислениям модели. Множитель ширины $\alpha$ равномерно «утончает» сеть на каждом слое.

Edge Impulse Studio может использовать как MobileNetV1 (изображения $96\times 96$), так и V2 (изображения $96\times 96$ или $160\times 160$) с несколькими значениями $\alpha$ (от 0,05 до 1,0). Например, наибольшая точность достигается у V2 с изображениями $160\times 160$ и $\alpha =1,0$. Однако есть компромисс: чем выше точность, тем больше памяти (около 1,3 МБ ОЗУ и 2,6 МБ ПЗУ) нужно для работы модели и тем выше задержка. Наименьший объём обеспечивает MobileNetV1 с $\alpha =0,10$ (около 53,2 КБ ОЗУ и 101 КБ ПЗУ).

Для этого проекта мы используем MobileNetV2 96x96 0.1 (или 0.05) с ожидаемым расходом памяти 265,3 КБ ОЗУ. Этой модели должно хватить для Nicla Vision с 1 МБ SRAM. На вкладке Transfer Learning выберите эту модель:

Обучение модели

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

Заглянем «под капот» и посмотрим, как Edge Impulse реализует политику аугментации данных:

# Реализация политики аугментации данных
def augment_image(image, label):
    # Случайно отражаем изображение по горизонтали
    image = tf.image.random_flip_left_right(image)

    # Увеличиваем размер изображения, затем случайно обрезаем его до
    # исходных размеров
    resize_factor = random.uniform(1, 1.2)
    new_height = math.floor(resize_factor * INPUT_SHAPE[0])
    new_width = math.floor(resize_factor * INPUT_SHAPE[1])
    image = tf.image.resize_with_crop_or_pad(image, new_height,
                                             new_width)
    image = tf.image.random_crop(image, size=INPUT_SHAPE)

    # Меняем яркость изображения
    image = tf.image.random_brightness(image, max_delta=0.2)

    return image, label

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

Последний слой модели будет содержать 12 нейронов с dropout 15 % для предотвращения переобучения. Вот результат обучения:

Результат отличный: оценочная задержка составляет 77 мс, что должно обеспечить около 13 кадров в секунду (FPS) при инференсе.

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

Теперь возьмём набор данных, отложенный в начале проекта, и подадим его на вход обученной модели:

Результат снова отличный.

Развёртывание модели

Теперь обученную модель можно развернуть как прошивку (FW) и запустить через OpenMV IDE на MicroPython, либо развернуть как библиотеку C/C++ или Arduino.

Библиотека Arduino

Сначала развернём модель как библиотеку Arduino:

Библиотеку нужно установить в Arduino IDE как архив .zip, а затем запустить скетч nicla_vision_camera.ino, который находится в разделе Examples под именем библиотеки.

По умолчанию Arduino Nicla Vision выделяет 512 КБ ОЗУ для ядра M7 и ещё 244 КБ в адресном пространстве M4. В коде это выделение изменено на 288 КБ, чтобы модель гарантированно работала на устройстве (malloc_addblock((void*)0x30000000, 288 * 1024);).

Результат хороший: измеренная задержка составила 86 мс.

Короткое видео с результатами инференса:

OpenMV

Обученную модель можно использовать с OpenMV двумя способами: как библиотеку и как прошивку (FW). При выборе прошивки Edge Impulse Studio генерирует оптимизированные модели, библиотеки и фреймворки, которые нужны для инференса. Рассмотрим этот вариант.

На вкладке Deploy выберите OpenMV Firmware и нажмите [Build].

На компьютере появится ZIP-файл. Откройте его:

Используйте инструмент Bootloader в OpenMV IDE, чтобы загрузить прошивку на плату (1):

Выберите нужный файл (.bin для Nicla-Vision):

Когда загрузка завершится, нажмите OK:

Если появится сообщение, что прошивка устарела, НЕ ОБНОВЛЯЙТЕ её. Выберите [NO].

Теперь откройте скрипт ei_image_classification.py, скачанный из Studio, и файл .bin для Nicla.

Запустите его. Направляя камеру на объекты, которые нужно классифицировать, вы увидите результат инференса в Serial Terminal.

Результат классификации появляется в Serial Terminal. Если результат трудно читать, добавьте в код новую строку с задержкой:

import time
while True:
...
	time.sleep_ms(200)  # Задержка 0,2 секунды

Изменение кода для вывода меток

Код от Edge Impulse можно изменить так, чтобы для проверки видеть результат инференса прямо на изображении в OpenMV IDE.

Загрузите код с GitHub или измените его, как показано ниже:

# Marcelo Rovai — NICLA Vision — классификация изображений
# Адаптировано из примера Edge Impulse — OpenMV Image Classification
# @24March25

import sensor
import time
import ml

sensor.reset()  # Сброс и инициализация датчика.
# Формат пикселей RGB565 (или GRAYSCALE)
sensor.set_pixformat(sensor.RGB565)
# Размер кадра QVGA (320x240)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((240, 240))  # Окно 240x240.
sensor.skip_frames(time=2000)  # Даём камере настроиться.

model = ml.Model("trained")#mobilenet, load_to_fb=True)

clock = time.clock()

while True:
    clock.tick()
    img = sensor.snapshot()

    fps = clock.fps()
    lat = clock.avg()
    print("**********\nPrediction:")
    # Объединяем метки и уверенность в список кортежей и сортируем его
    # по значениям уверенности.
    sorted_list = sorted(
        zip(model.labels, model.predict([img])[0].flatten().tolist()),
      key=lambda x: x[1], reverse=True
    )

    # Выводим только класс с наибольшей вероятностью
    max_val = sorted_list[0][1]
    max_lbl = sorted_list[0][0]

    if max_val < 0.5:
        max_lbl = 'uncertain'

    print("{} with a prob of {:.2f}".format(max_lbl, max_val))
    print("FPS: {:.2f} fps ==> latency: {:.0f} ms".format(fps, lat))

    # Выводим метку с наибольшей вероятностью на просмотрщике изображения
    img.draw_string(
    10, 10,
    max_lbl + "\n{:.2f}".format(max_val),
    mono_space = False,
    scale=3
    )

    time.sleep_ms(500)  # Пауза 0.5 секунды

Вот результат:

Обратите внимание: задержка (136 мс) почти вдвое больше, чем при работе напрямую через Arduino IDE (86 мс). Это происходит потому, что мы используем IDE как интерфейс, а также из-за времени ожидания готовности камеры. Если запустить таймер непосредственно перед инференсом, задержка должна снизиться примерно до 70 мс.

При подключении к IDE NiclaV работает примерно вдвое медленнее. После отключения FPS должен вырасти.

Пост-обработка со светодиодами

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

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

# Marcelo Rovai — NICLA Vision — классификация изображений со светодиодами
# Адаптировано из примера Edge Impulse — OpenMV Image Classification
# @24Aug23

import sensor, time, ml
from machine import LED

ledRed = LED("LED_RED")
ledGre = LED("LED_GREEN")
ledBlu = LED("LED_BLUE")

sensor.reset()  # Сброс и инициализация датчика.
# Формат пикселей RGB565 (или GRAYSCALE)
sensor.set_pixformat(sensor.RGB565)
# Размер кадра QVGA (320x240)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((240, 240))  # Окно 240x240.
sensor.skip_frames(time=2000)  # Даём камере настроиться.

model = ml.Model("trained")#mobilenet, load_to_fb=True)

ledRed.off()
ledGre.off()
ledBlu.off()

clock = time.clock()

def setLEDs(max_lbl):
	if max_lbl == 'uncertain':
		ledRed.on()
		ledGre.off()
		ledBlu.off()

	if max_lbl == 'periquito':
		ledRed.off()
		ledGre.on()
		ledBlu.off()

	if max_lbl == 'robot':
		ledRed.off()
		ledGre.off()
		ledBlu.on()

	if max_lbl == 'background':
		ledRed.off()
		ledGre.off()
		ledBlu.off()

while True:
    img = sensor.snapshot()

    clock.tick()
    fps = clock.fps()
    lat = clock.avg()
    print("**********\nPrediction:")
    sorted_list = sorted(
        zip(model.labels, model.predict([img])[0].flatten().tolist()),
      key=lambda x: x[1], reverse=True
    )

    # Выводим только класс с наибольшей вероятностью
    max_val = sorted_list[0][1]
    max_lbl = sorted_list[0][0]

    if max_val < 0.5:
        max_lbl = 'uncertain'

    print("{} with a prob of {:.2f}".format(max_lbl, max_val))
    print("FPS: {:.2f} fps ==> latency: {:.0f} ms".format(fps, lat))

    # Выводим метку с наибольшей вероятностью на просмотрщике изображения
    img.draw_string(
    10, 10,
    max_lbl + "\n{:.2f}".format(max_val),
    mono_space = False,
    scale=3
    )

    setLEDs(max_lbl)
    time.sleep_ms(200)  # Пауза 0.2 секунды

Теперь каждый раз, когда какой-либо класс получает результат выше 0,8, загорается соответствующий светодиод:

• Красный светодиод горит: Uncertain (ни один класс не выше 0,8);
• Зелёный светодиод горит: Periquito > 0,8;
• Синий светодиод горит: Robot > 0,8;
• Все светодиоды выключены: Background > 0,8.

Вот результат:

Подробнее:

Неофициальный сравнительный тест классификации изображений

Для встраиваемого машинного обучения (TinyML) можно использовать несколько отладочных плат. Чаще всего для задач компьютерного зрения с малым энергопотреблением применяют ESP32-CAM, Seeed XIAO ESP32S3 Sense, Arduino Nicla Vision и Arduino Portenta.

Воспользовавшись возможностью, мы развернули одну и ту же обученную модель на ESP-CAM, XIAO и Portenta (для последней модель обучили заново на изображениях в оттенках серого, чтобы она подходила к её камере). Вот результат, когда модели развёрнуты как библиотеки Arduino:

Итоги

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

• Автономный транспорт: слияние датчиков, данные лидара и алгоритмы компьютерного зрения для навигации и принятия решений.
• Здравоохранение: автоматическая диагностика заболеваний по снимкам МРТ, рентгена и КТ.
• Розничная торговля: автоматические кассовые системы, которые распознают товары при проезде через сканер.
• Безопасность и наблюдение: распознавание лиц, обнаружение аномалий и отслеживание объектов в видеопотоке в реальном времени.
• Дополненная реальность: обнаружение и классификация объектов для наложения цифровой информации на реальный мир.
• Промышленная автоматизация: визуальный контроль продукции, предиктивное обслуживание, наведение роботов и дронов.
• Сельское хозяйство: мониторинг посевов с дронов и автоматизированная уборка урожая.
• Обработка естественного языка: создание подписей к изображениям и визуальные вопросно-ответные системы.
• Распознавание жестов: для игр, перевода жестового языка и взаимодействия человека с машиной.
• Рекомендательные системы: рекомендации товаров на основе изображений в электронной коммерции.

Ресурсы

• Коды на MicroPython

• Набор данных

• Проект Edge Impulse

Распознавание ключевых слов (KWS)

Промпт DALL·E 3: мультфильм в стиле 1950-х в старинной лаборатории аудиоисследований. В центре две учёные-женщины. Одна держит увеличительное стекло и внимательно рассматривает старую схему, другая делает записи. На деревянном столе несколько плат с датчиками, в том числе с микрофоном. За платами стоит компьютер с округлой задней панелью, на экране которого открыта Arduino IDE. В IDE видны код назначения выводов светодиодов и инференс модели машинного обучения для распознавания голосовых команд. В окне Serial Monitor выводятся распознанные команды «yes» и «no». Атмосфера комнаты ностальгическая: старинные лампы, классические инструменты анализа звука и графики БПФ и временных кривых.

Обзор

Мы уже исследовали плату Nicla Vision в приложениях классификации изображений и обнаружения объектов. Теперь переходим к голосовым приложениям: проект распознавания ключевых слов (Keyword Spotting, KWS).

Как рассказано в практическом руководстве «Инженерия признаков для KWS», распознавание ключевых слов (KWS) используется во многих системах распознавания речи и позволяет устройствам реагировать на определённые слова или фразы. Хотя эта технология лежит в основе популярных устройств вроде Google Assistant или Amazon Alexa, её можно реализовать и на маленьких маломощных устройствах. Это руководство проведёт вас через реализацию системы KWS с помощью TinyML на отладочной плате Nicla Vision с цифровым микрофоном.

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

Как работает голосовой помощник?

Как уже говорилось, голосовые помощники на рынке, например Google Home или Amazon Echo Dot, реагируют на человека, только когда их «будят» определённые ключевые слова: «Hey Google» в первом случае и «Alexa» во втором.

Иначе говоря, распознавание голосовых команд основано на многоступенчатой модели, или каскадном обнаружении (Cascade Detection).

Этап 1: маленький микропроцессор внутри Echo Dot или Google Home постоянно слушает, ожидая, когда будет распознано ключевое слово, с помощью модели TinyML на периферии (приложение KWS).

Этап 2: данные отправляются в облако и обрабатываются более крупной моделью, только если приложение KWS на этапе 1 сработало.

Видео ниже показывает пример программирования Google Assistant на Raspberry Pi (этап 2) с устройством TinyML Arduino Nano 33 BLE (этап 1).

Чтобы изучить описанный проект Google Assistant, см. руководство: Building an Intelligent Voice Assistant From Scratch.

В этом проекте KWS мы сосредоточимся на этапе 1 (KWS, или Keyword Spotting): здесь мы используем Nicla Vision, у которой есть цифровой микрофон для распознавания ключевого слова.

Практический проект KWS

Схема ниже показывает, как должно работать итоговое приложение KWS (во время инференса):

Наше приложение KWS будет распознавать четыре класса звуков:

• YES (ключевое слово 1);
• NO (ключевое слово 2);
• NOISE (слов нет, есть только фоновый шум);
• UNKNOWN (смесь слов, отличных от YES и NO).

Для реальных проектов всегда полезно включать в набор, помимо ключевых слов, и другие звуки, например «Noise» (фон) и «Unknown» (неизвестные слова).

Рабочий процесс машинного обучения

Главный компонент приложения KWS — его модель. Поэтому нужно обучить модель на наших ключевых словах, шуме и других словах («unknown»):

Набор данных

Важнейший компонент любого рабочего процесса машинного обучения — набор данных. Выбрав конкретные ключевые слова (в нашем случае YES и NO), мы можем воспользоваться набором данных, который разработал Пит Уорден (Pete Warden): «Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition». В этом наборе 35 ключевых слов (по более чем 1000 образцов каждого), например yes, no, stop и go. Для таких слов, как yes и no, можно получить по 1500 образцов.

Небольшую часть набора данных можно скачать из Edge Impulse Studio (готовый набор данных для распознавания ключевых слов). Он включает образцы четырёх классов, которые мы будем использовать в этом проекте: yes, no, noise и background. Для этого выполните следующие шаги:

• Скачайте набор ключевых слов.
• Распакуйте файл в удобное место.

Загрузка набора данных в Edge Impulse Studio

Создайте новый проект в Edge Impulse Studio (EIS) и выберите инструмент Upload Existing Data в разделе Data Acquisition. Выберите файлы для загрузки:

Задайте метку, выберите Automatically split between train and test и нажмите Upload data, чтобы загрузить данные в EIS. Повторите для всех классов.

Теперь набор данных появится в разделе Data acquisition. Обратите внимание: примерно 6000 образцов (по 1500 на каждый класс) разделены на обучающую (4800) и тестовую (1200) выборки.

Сбор дополнительных аудиоданных

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

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

Когда мы произносим ключевое слово, звуковые волны нужно преобразовать в аудиоданные. Преобразование выполняется дискретизацией сигнала с микрофона с частотой 16 кГц и разрядностью 16 бит на отсчёт.

Поэтому подойдёт любое устройство, которое может создавать аудиоданные с такими базовыми параметрами (16 кГц / 16 бит). В качестве устройства можно использовать NiclaV, компьютер или даже телефон.

Использование NiclaV и Edge Impulse Studio

Как мы узнали в главе «Настройка Nicla Vision», EIS официально поддерживает Nicla Vision, что упрощает сбор данных с её датчиков, в том числе с микрофона. Поэтому создайте новый проект в EIS и подключите к нему Nicla, выполнив следующие шаги:

• Скачайте последнюю версию прошивки EIS и распакуйте её.

• Откройте ZIP-архив на компьютере и выберите загрузчик, соответствующий вашей ОС:

• Переведите NiclaV в режим загрузки, дважды нажав кнопку reset.

• Загрузите двоичный файл arduino-nicla-vision.bin на плату, запустив пакетный файл для своей ОС.

Откройте свой проект в EIS и на вкладке Data Acquisition выберите WebUSB. Откроется окно; выберите вариант, в котором видно, что Nicla is paired, и нажмите [Connect].

В разделе Collect Data на вкладке Data Acquisition можно выбрать, данные какого датчика собирать. Выберите Built-in microphone, задайте label (например, yes), частоту дискретизации Frequency [16000 Гц] и длительность образца Sample length (in milliseconds), например [10 с]. Нажмите Start sampling.

Данные набора Пита имеют длительность 1 с, а записанные образцы — по 10 с, и их нужно разбить на отрезки по 1 с. Нажмите три точки после названия образца и выберите Split sample.

Откроется окно инструмента разбиения (Split).

В инструменте разбейте данные на записи по 1 секунде (1000 мс). При необходимости добавьте или удалите сегменты. Эту процедуру нужно повторить для всех новых образцов.

Использование смартфона и EI Studio

Аудиоданные можно также записывать на ПК или смартфон с частотой дискретизации 16 кГц и разрядностью 16 бит.

Откройте Devices, отсканируйте QR Code телефоном и перейдите по ссылке. В браузере откроется приложение для сбора данных. Выберите Collecting Audio, затем задайте Label, длительность записи Length и Category.

Повторите ту же процедуру, что и с NiclaV.

Для записи звука можно использовать любое приложение, например Audacity, при условии что образцы записаны с частотой 16 кГц и разрядностью 16 бит.

Создание Impulse (предобработка и определение модели)

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

Проектирование Impulse

Сначала мы возьмём точки данных с окном в 1 секунду, применим аугментацию и будем сдвигать окно с интервалом 500 мс. Обратите внимание, что включён параметр zero-pad data (дополнение нулями). Он важен: образцы короче 1 секунды дополняются «нулями» (в некоторых случаях образцы могут быть короче окна 1000 мс в инструменте разбиения — чтобы избежать шумов и выбросов).

Каждый образец аудио длиной 1 секунда предобрабатывается и преобразуется в изображение (например, $13\times 49\times 1$). Как обсуждалось в практическом руководстве «Инженерия признаков для KWS», мы будем использовать Audio (MFCC), который извлекает признаки из аудиосигналов с помощью мел-частотных кепстральных коэффициентов, хорошо подходящих для человеческого голоса, то есть для нашей задачи.

Затем выберем блок Classification, чтобы построить модель с нуля на основе свёрточной нейронной сети (CNN).

Вместо этого можно использовать блок Transfer Learning (Keyword Spotting), который дообучает предобученную модель распознавания ключевых слов на ваших данных. Такой подход хорошо работает с относительно небольшими наборами ключевых слов.

Предобработка (MFCC)

Следующий шаг — создать признаки для обучения на следующем этапе.

Можно оставить значения параметров по умолчанию, но мы воспользуемся опцией DSP Autotune parameters.

Мы возьмём Raw features (наши аудиоданные длительностью 1 секунда с частотой 16 кГц) и с помощью блока обработки MFCC вычислим Processed features. На каждые 16 000 сырых признаков (16 000 $\times$ 1 секунда) мы получим 637 обработанных признаков $(13\times 49)$.

Результат показывает, что предобработка данных потребовала мало памяти (16 КБ) и имеет задержку 34 мс, что отлично. Например, на Arduino Nano (Cortex-M4f @ 64 МГц) та же предобработка займёт около 480 мс. Выбранные параметры, например FFT length [512], существенно влияют на задержку.

Теперь нажмём Save parameters и перейдём на вкладку Generated features, где будут созданы реальные признаки. Используя UMAP, метод снижения размерности, Feature explorer показывает, как признаки распределены на двумерном графике.

Результат выглядит хорошо: признаки yes (красные) и no (синие) визуально чётко разделены. Признаки unknown расположены ближе к области no, чем к yes. Это говорит о том, что ключевое слово no склонно давать больше ложных срабатываний.

Заглядываем под капот

Чтобы лучше понять, как обрабатывается сырой звук, изучите главу «Инженерия признаков для KWS». Поэкспериментировать с генерацией признаков MFCC можно, скачав блокнот с GitHub или открыв его в Colab.

Проектирование модели и обучение

Мы используем простую свёрточную нейронную сеть (CNN), протестированную с одномерными (1D) и двумерными (2D) свёртками. Базовая архитектура содержит два блока «свёртка + MaxPooling» (с [8] и [16] фильтрами соответственно) и Dropout [0,25] для 1D и [0,5] для 2D. Последний слой после Flatten содержит [4] нейрона — по одному на каждый класс:

Гиперпараметры: Learning Rate — [0,005], модель обучается за [100] эпох. Также включим метод аугментации данных на основе SpecAugment. Модели 1D и 2D обучались с одинаковыми гиперпараметрами. Архитектура 1D дала лучший общий результат (точность 90,5 % против 88 % у 2D), поэтому мы используем 1D.

Свёртки 1D эффективнее, потому что требуют меньше параметров, чем 2D, и поэтому лучше подходят для сред с ограниченными ресурсами.

Также стоит посмотреть на матрицу ошибок для 1D. F1-мера для yes составляет 95 %, для no — 91 %. Этого и следовало ожидать по результатам Feature Explorer (no и unknown находятся на близком расстоянии). Чтобы улучшить результат, можно внимательно изучить образцы с ошибками.

Послушайте образцы, которые распознаны неверно. Например, для yes большинство ошибок связано с тем, что yes произносилось как «yeh». Вы можете записать дополнительные образцы и переобучить модель.

Заглядываем под капот

Если вы хотите понять, что происходит «под капотом», можно скачать предобработанный набор данных (MFCC training data) на вкладке Dashboard и запустить этот блокнот Jupyter — можно экспериментировать с кодом или открыть его в Colab. Например, можно проанализировать точность по эпохам:

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

Тестирование модели на данных, отложенных для проверки (тестовых данных), дало точность примерно 76 %.

Если посмотреть F1-меру, для YES получилось 0,90 — отличный результат, ведь мы ожидаем использовать это слово как основной «триггер» в проекте KWS. Худший результат (0,70) — у UNKNOWN, и это нормально.

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

Классификация в реальном времени

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

Развёртывание и инференс

EIS упакует все нужные библиотеки, функции предобработки и обученные модели и загрузит их на ваш компьютер. Перейдите в раздел Deployment, выберите Arduino Library, внизу выберите Quantized (Int8) и нажмите Build.

Когда вы нажмёте Build, будет создан ZIP-файл и скачан на компьютер. В Arduino IDE откройте вкладку Sketch, выберите Add .ZIP Library и укажите ZIP-файл, скачанный из EIS:

Теперь пора провести настоящий тест. Мы будем делать инференс, полностью отключившись от EIS. Используем пример кода NiclaV, созданный при развёртывании библиотеки Arduino.

В Arduino IDE откройте вкладку File/Examples, найдите свой проект и выберите nicla-vision/nicla-vision_microphone (или nicla-vision_microphone_continuous):

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

Постобработка

Теперь, когда мы знаем, что модель работает и распознаёт наши ключевые слова, изменим код, чтобы увидеть результат на NiclaV полностью автономно — без подключения к ПК, от батареи, пауэрбанка или отдельного источника 5 В.

Идея такая: когда распознано ключевое слово YES, загорается зелёный светодиод; при NO — красный; если звучит UNKNOWN — синий; при наличии шума (без ключевого слова) все светодиоды выключены.

Изменим один из примеров кода. Сделаем это на примере nicla-vision_microphone_continuous.

Начнём с инициализации светодиодов:

...
void setup()
{
        // Когда отладка кода завершена, можно закомментировать или удалить
        // часть кода, связанную с Serial
    Serial.begin(115200);
    while (!Serial);
    Serial.println("Inferencing - Nicla Vision KWS with LEDs");

    // Выводы встроенных RGB-светодиодов Arduino NiclaV
    pinMode(LEDR, OUTPUT);
    pinMode(LEDG, OUTPUT);
    pinMode(LEDB, OUTPUT);

    // По умолчанию светодиоды выключены.
    // Примечание: RGB-светодиоды Arduino Nicla Vision
    // горят, когда вывод в состоянии LOW, и гаснут, когда в HIGH.
    digitalWrite(LEDR, HIGH);
    digitalWrite(LEDG, HIGH);
    digitalWrite(LEDB, HIGH);
...
}

Создайте две функции. Первая, turn_off_leds(), выключает все RGB-светодиоды:

/*
 * @brief      Функция turn_off_leds — выключает все RGB-светодиоды
 */
void turn_off_leds(){
    digitalWrite(LEDR, HIGH);
    digitalWrite(LEDG, HIGH);
    digitalWrite(LEDB, HIGH);
}

Вторая функция, turn_on_led(), включает RGB-светодиоды в соответствии с наиболее вероятным результатом классификатора:

/*
 * @brief     Функция turn_on_leds — включает RGB-светодиоды
 * @param[in] pred_index
 *            no:       [0] ==> горит красный
 *            noise:    [1] ==> все выключены
 *            unknown:  [2] ==> горит синий
 *            yes:      [3] ==> горит зелёный
 */
void turn_on_leds(int pred_index) {
  switch (pred_index)
  {
    case 0:
      turn_off_leds();
      digitalWrite(LEDR, LOW);
      break;

    case 1:
      turn_off_leds();
      break;

    case 2:
      turn_off_leds();
      digitalWrite(LEDB, LOW);
      break;

    case 3:
      turn_off_leds();
      digitalWrite(LEDG, LOW);
      break;
  }
}

И измените фрагмент // print the predictions в функции loop():

...

 if (++print_results >= (EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW)) {
     // вывод предсказаний
     ei_printf("Predictions ");
     ei_printf("(DSP: %d ms., Classification: %d ms., "
               "Anomaly: %d ms.)",
         result.timing.dsp, result.timing.classification,
         result.timing.anomaly);
     ei_printf(": \n");
     int pred_index = 0;     // Инициализация pred_index
     float pred_value = 0;   // Инициализация pred_value
     for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
         if (result.classification[ix].value > pred_value){
             pred_index = ix;
             pred_value = result.classification[ix].value;
         }
         // ei_printf("    %s: ",
         // result.classification[ix].label);
         // ei_printf_float(result.classification[ix].value);
         // ei_printf("\n");
     }
     ei_printf("  PREDICTION: ==> %s with probability %.2f\n",
               result.classification[pred_index].label,
               pred_value);
     turn_on_leds (pred_index);

#if EI_CLASSIFIER_HAS_ANOMALY == 1
        ei_printf("    anomaly score: ");
        ei_printf_float(result.anomaly);
        ei_printf("\n");
#endif

        print_results = 0;
    }
}

...

Полный код можно найти в репозитории проекта на GitHub.

Загрузите скетч на плату и протестируйте реальный инференс. Идея такая: зелёный светодиод горит при распознавании ключевого слова YES, красный — при NO, а любое другое слово включает синий. Все светодиоды должны быть выключены при тишине или фоновом шуме. Учтите, что тот же приём может «запускать» внешнее устройство для выполнения нужного действия вместо включения светодиода, как мы видели во введении.

Итоги

Блокноты и код, использованные в этой практической работе, вы найдёте в репозитории GitHub.

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

• Безопасность (обнаружение битого стекла, выстрелов);
• Промышленность (обнаружение аномалий);
• Медицина (храп, кашель, заболевания лёгких);
• Природа (контроль ульев, звуки насекомых, борьба с браконьерством).

Ресурсы

• Подмножество набора Google Speech Commands

• Блокнот Colab: KWS MFCC Analysis

• Блокнот Colab: KWS_CNN_training

• Код постобработки для Arduino

• Проект Edge Impulse

Классификация движения и обнаружение аномалий

Промпт DALL·E 3: мультфильм в стиле 1950-х, изображающий лабораторию исследования движения. В центре комнаты стоит имитация контейнера для перевозки грузов на грузовиках, лодках и погрузчиках. Контейнер детализирован заклёпками и маркировкой, характерной для промышленных грузовых ящиков. Вокруг него — старинное оборудование: осциллограф, различные массивы датчиков и большие бумажные рулоны с записанными данными. На стенах висят учебные плакаты о безопасности перевозок и логистике. Общая атмосфера комнаты ностальгическая и научная, с оттенком промышленного стиля.

Обзор

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

В этой практической работе мы решим реальные задачи, связанные с транспортом. Мы создадим систему классификации движения и обнаружения аномалий на базе платы Arduino Nicla Vision, Arduino IDE и Edge Impulse Studio. Этот проект поможет понять, как контейнеры испытывают различные силы и движения на разных этапах перевозки: наземная и морская перевозка, вертикальное перемещение погрузчиком и периоды простоя на складе.

Цели обучения

• Настройка платы Arduino Nicla Vision
• Сбор и предобработка данных
• Построение модели классификации движения
• Реализация обнаружения аномалий
• Тестирование и анализ в реальных условиях

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

Установка и проверка IMU

В этом проекте мы будем использовать акселерометр. Как обсуждалось в практической работе «Настройка Nicla Vision», на плате Nicla Vision есть встроенный 6-осевой IMU: 3D-гироскоп и 3D-акселерометр LSM6DSOX. Проверьте, установлена ли библиотека IMU LSM6DSOX. Если нет, установите её.

Затем откройте Examples > Arduino_LSM6DSOX > SimpleAccelerometer и запустите тест акселерометра. Работоспособность можно проверить через Serial Monitor или Plotter в IDE. Значения выражены в g (земное ускорение) с диапазоном по умолчанию ±4 g:

Определение частоты дискретизации

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

1. Характер движения. Разные виды транспорта (наземный, морской и т. д.) могут включать разные диапазоны частот движения. Более быстрые движения могут требовать более высокой частоты дискретизации.

2. Аппаратные ограничения. Плата Arduino Nicla Vision и связанные с ней датчики могут ограничивать скорость дискретизации данных.

3. Вычислительные ресурсы. Более высокая частота дискретизации создаёт больше данных, что может быть ресурсоёмко, особенно в среде TinyML.

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

5. Хранение данных. Более частая дискретизация требует больше места для хранения — ещё одно важное соображение для встраиваемых систем с ограниченной памятью.

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

Определим скетч, который позволит собирать данные с заданной частотой дискретизации (например, 50 Гц):

/*
 * Основано на примере Edge Impulse Data Forwarder (Arduino)
  - https://docs.edgeimpulse.com/docs/cli-data-forwarder
 * Разработано M.Rovai @11May23
 */

/* Подключение библиотек ----------------------------- */
#include <Arduino_LSM6DSOX.h>

/* Константы ----------------------------------------- */
#define CONVERT_G_TO_MS2 9.80665f
#define FREQUENCY_HZ        50
#define INTERVAL_MS         (1000 / (FREQUENCY_HZ + 1))

static unsigned long last_interval_ms = 0;
float x, y, z;

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
  }
}

void loop() {
  if (millis() > last_interval_ms + INTERVAL_MS) {
    last_interval_ms = millis();

    if (IMU.accelerationAvailable()) {
      // Считываем сырые измерения ускорения с устройства
      IMU.readAcceleration(x, y, z);

      // переводим в м/с2
      float ax_m_s2 = x * CONVERT_G_TO_MS2;
      float ay_m_s2 = y * CONVERT_G_TO_MS2;
      float az_m_s2 = z * CONVERT_G_TO_MS2;

      Serial.print(ax_m_s2);
      Serial.print("\t");
      Serial.print(ay_m_s2);
      Serial.print("\t");
      Serial.println(az_m_s2);
    }
  }
}

Загрузите скетч и посмотрите Serial Monitor: мы видим, что собираем 50 отсчётов в секунду.

Обратите внимание: когда плата Nicla лежит на столе (камерой вниз), ось $z$ показывает около 9,8 м/с${}^2$ — ожидаемое ускорение свободного падения.

Кейс: имитация перевозки контейнера

Чтобы сделать руководство понятнее и ближе к практике, мы смоделируем перевозку контейнера (точнее, пакета) в разных сценариях. С помощью встроенного акселерометра платы Arduino Nicla Vision мы будем записывать данные о движении, вручную имитируя условия:

1. Наземная перевозка (автомобилем или поездом);
2. Морская перевозка;
3. Вертикальное перемещение погрузчиком (fork-lift);
4. Стационарный период простоя на складе.

Из приведённых изображений для нашей симуляции следует, что преимущественно горизонтальные движения (по осям $x$ или $y$) относятся к классу «Наземный» (Terrestrial), вертикальные движения (по оси $z$) — к классу «Погрузчик» (Lift), отсутствие движения — к классу «Простой» (Idle), а движение по всем трём осям — к классу «Морской» (Maritime).

Сбор данных

Для сбора данных есть несколько вариантов. В реальной ситуации устройство можно подключить непосредственно к одному контейнеру, а данные записывать в файл (например, .CSV) на SD-карту (через SPI) или в офлайн-хранилище на компьютере. Данные также можно передавать удалённо на ближайшее устройство, например на телефон, по Bluetooth (как сделано в этом проекте: Sensor DataLogger). Когда набор данных собран и сохранён в файле .CSV, его можно загрузить в Studio с помощью CSV Wizard.

В этом видео вы можете узнать о других способах отправки данных в Edge Impulse Studio.

Подключение устройства к Edge Impulse

Мы подключим Nicla непосредственно к Edge Impulse Studio, которая также будет использоваться для предобработки данных, обучения модели, тестирования и развёртывания. Для этого есть два варианта:

1. Скачать последнюю прошивку и подключить её напрямую в разделе Data Collection.
2. Использовать CLI Data Forwarder, чтобы собирать данные датчика и отправлять их в Studio.

Первый вариант проще, как мы видели в практической работе «Настройка Nicla Vision», но второй даёт больше гибкости при сборе данных, например при задании частоты дискретизации. Выберем второй вариант.

Создайте новый проект в Edge Impulse Studio (EIS) и подключите к нему Nicla, выполнив следующие шаги:

1. Установите Edge Impulse CLI и Node.js на компьютер.
2. Загрузите скетч для сбора данных (тот, что обсуждался выше в этом руководстве).
3. Используйте CLI Data Forwarder, чтобы собирать данные акселерометра Nicla и отправлять их в Studio, как показано на схеме:

Запустите CLI Data Forwarder в терминале. Если делаете это впервые, введите команду:

$ edge-impulse-data-forwarder --clean

Затем введите учётные данные EI, выберите проект, переменные (например, accX, accY и accZ) и имя устройства (например, NiclaV):

Откройте раздел Devices в своём проекте EI и проверьте, что устройство подключено (точка должна быть зелёной):

Вы можете клонировать проект, созданный для этой практической работы: NICLA Vision Movement Classification.

Сбор данных в Studio

В разделе Data Acquisition вы должны увидеть, что ваша плата [NiclaV] подключена. Датчик доступен: [sensor with 3 axes (accX, accY, accZ)], с частотой дискретизации [50 Hz]. Studio предлагает длительность образца [10000] мс (10 с). Осталось задать метку образца. Начнём с [terrestrial]:

Наземная перевозка (паллеты в грузовике или поезде): движение по горизонтали. Нажмите [Start Sample] и перемещайте устройство горизонтально, сохраняя одно направление над столом. Через 10 с данные загрузятся в Studio. Вот как выглядит записанный образец:

Как и ожидалось, движение зафиксировано в основном по оси $Y$ (зелёная). Синяя линия — ось $Z$, около −10 м/с${}^2$ (камера Nicla смотрит вверх).

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

Морская перевозка (паллеты на лодках в бушующем океане). Движение фиксируется по всем трём осям:

Погрузчик (паллеты, которые вертикально поднимает погрузчик). Движение фиксируется только по оси $Z$:

Простой (паллеты на складе). Акселерометр не фиксирует движения:

Например, можно записать по 2 минуты (двенадцать образцов по 10 секунд) для каждого из четырёх классов — всего 8 минут данных. Через меню three dots после каждого образца выберите 2 из них и отложите для тестовой выборки. Или можно воспользоваться автоматическим инструментом Train/Test Split в разделе Danger Zone на вкладке Dashboard. Ниже показан итоговый набор данных:

Когда набор данных собран, его можно детальнее изучить с помощью Data Explorer — визуального инструмента для поиска выбросов и неверно размеченных данных (с его помощью их можно исправить). Data Explorer сначала извлекает осмысленные признаки из данных (применяя обработку сигналов и встраивания нейронной сети), а затем использует алгоритм снижения размерности, например PCA или t-SNE, чтобы отобразить эти признаки в двумерное пространство. Так вы получаете обзор всего набора данных одним взглядом.

В нашем случае набор данных выглядит корректно (хорошее разделение классов). Однако PCA показывает возможные проблемы между классами «морской» (зелёный) и «погрузчик» (оранжевый). Это ожидаемо: на лодке движение иногда может быть только «вертикальным».

Проектирование Impulse

Следующий шаг — определение нашего Impulse. Он получает сырые данные, с помощью обработки сигналов извлекает признаки и передаёт их как входной тензор в блок обучения для классификации новых данных. Перейдите в Impulse Design и выберите Create Impulse. Studio предложит базовую конструкцию. Добавим также второй блок обучения для Anomaly Detection.

Эта вторая модель использует K-means. Если представить, что известные классы — это кластеры, то любой образец, который не вписывается ни в один из них, может быть выбросом, аномалией: например, контейнер, упавший с корабля в океан или сорвавшийся с погрузчика.

Частота дискретизации должна определиться автоматически; если нет — введите её: [50] Гц. Studio предлагает размер окна 2 секунды ([2000] мс) со скользящим окном шагом [20] мс. На этом шаге мы предобрабатываем захваченные данные (временные ряды), создавая табличный набор признаков, который будет входом для нейронной сети-классификатора (DNN) и модели обнаружения аномалий (K-Means), как показано ниже:

Разберём эти шаги и параметры подробнее, чтобы понять, что мы делаем.

Обзор предобработки данных

Предобработка данных — это извлечение признаков из набора данных, снятого акселерометром: обработка и анализ сырых данных. Акселерометры измеряют ускорение объекта по одной или нескольким осям (обычно по трём, обозначаемым $X$, $Y$ и $Z$). Эти измерения позволяют понять различные аспекты движения объекта: характер перемещений и вибрации.

Сырые данные акселерометра могут быть зашумлёнными и содержать ошибки или лишнюю информацию. Шаги предобработки, например фильтрация и нормализация, очищают и стандартизируют данные, делая их более подходящими для извлечения признаков. В нашем случае данные нужно разбить на небольшие сегменты, или окна. Это помогает сосредоточиться на конкретных событиях или активности в наборе данных, делая извлечение признаков более управляемым и содержательным. Выбор размера окна и перекрытия (шага окна) зависит от приложения и частоты интересующих событий. Как правило, стоит стремиться захватить пару «циклов данных».

При частоте дискретизации (SR) 50 Гц и размере окна 2 секунды мы получим 100 отсчётов на ось, или 300 всего (3 оси $\times$ 2 секунды $\times$ 50 отсчётов). Окно будем сдвигать каждые 200 мс, создавая более крупный набор данных, где каждый экземпляр содержит 300 сырых признаков.

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

• Признаки временной области описывают статистические свойства данных внутри каждого сегмента: среднее, медиану, стандартное отклонение, асимметрию (skewness), эксцесс (kurtosis) и частоту переходов через ноль (zero-crossing rate).
• Признаки частотной области получают, преобразуя данные в частотную область с помощью таких методов, как быстрое преобразование Фурье (FFT). К типичным признакам частотной области относятся спектр мощности, спектральная энергия, доминирующие частоты (амплитуда и частота) и спектральная энтропия.
• Признаки временно-частотной области объединяют информацию о времени и частоте, например кратковременное преобразование Фурье (STFT) или дискретное вейвлет-преобразование (DWT). Они дают более детальное представление о том, как частотное содержание сигнала меняется во времени.

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

Спектральные признаки в EI Studio

Предобработка данных — сложная область для встраиваемого машинного обучения, но Edge Impulse помогает справиться с ней благодаря шагу цифровой обработки сигналов (DSP) и, в частности, блоку спектральных признаков (Spectral Features Block).

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

Для нашего проекта, поскольку временной сигнал непрерывен, стоит использовать FFT с длиной, например, [32].

Статистические признаки временной области для каждой оси (канала):

• RMS (среднеквадратичное значение): 1 признак;
• Skewness (асимметрия): 1 признак;
• Kurtosis (эксцесс): 1 признак.

Спектральные признаки частотной области для каждой оси (канала):

• Spectral Power (спектральная мощность): 16 признаков (длина FFT / 2);
• Skewness (асимметрия): 1 признак;
• Kurtosis (эксцесс): 1 признак.

Таким образом, для длины FFT 32 точки блок спектрального анализа выдаёт 21 признак на ось (всего 63 признака).

Подробнее о том, как вычисляется каждый признак, можно узнать из блокнота Edge Impulse — Spectral Features Block Analysis, из статьи TinyML under the hood: Spectral Analysis или открыв блокнот прямо в Google Colab.

Генерация признаков

Когда мы поняли, что делает предобработка, пора довести дело до конца. Возьмём сырые данные (временные ряды) и преобразуем их в табличные данные. Для этого перейдите в раздел Spectral Features на вкладке Parameters, задайте основные параметры, как обсуждалось в предыдущем разделе ([FFT] с [32] точками), и выберите [Save Parameters]:

В верхнем меню выберите опцию Generate Features и кнопку Generate Features. Каждое окно данных длительностью 2 секунды будет преобразовано в одну точку данных из 63 признаков.

Feature Explorer покажет эти данные в двумерном виде с помощью UMAP. Uniform Manifold Approximation and Projection (UMAP) — метод снижения размерности, который используется для визуализации, как и t-SNE, но применим и для общего нелинейного снижения размерности.

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

Обучение моделей

Наш классификатор будет полносвязной нейронной сетью (DNN): входной слой из 63 нейронов, два скрытых слоя с 20 и 10 нейронами и выходной слой из четырёх нейронов (по одному на каждый класс), как показано здесь:

Гиперпараметры: скорость обучения (Learning Rate) [0.005], размер батча (Batch size) [32], доля данных для валидации [20] % и [30] эпох. После обучения точность составляет 98,5 %. Затраты памяти и задержка при этом незначительны.

Для обнаружения аномалий мы выберем предложенные признаки — те самые наиболее важные признаки, отобранные при извлечении, плюс RMS по оси accZ. Количество кластеров составит [32], как предлагает Studio:

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

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

По умолчанию минимальный порог для неопределённого результата — [0.6] для классификации и [0.3] для аномалий. Поскольку классов четыре (их сумма должна быть равна 1,0), можно также задать более низкий порог, при котором класс считается допустимым (например, 0,4). Пороги уверенности можно задать через пункт Set confidence thresholds в меню three dots рядом с кнопкой Classify all.

Также можно выполнить классификацию в реальном времени с помощью вашего устройства (оно должно оставаться подключённым к Studio).

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

Развёртывание

Настало время развернуть блок предобработки и обученную модель на Nicla. Studio упакует все нужные библиотеки, функции предобработки и обученные модели и загрузит их на компьютер. Выберите опцию Arduino Library, внизу выберите Quantized (Int8) или Unoptimized (float32) и нажмите [Build]. Будет создан ZIP-файл, который скачается на компьютер.

В Arduino IDE откройте вкладку Sketch, выберите Add.ZIP Library и укажите ZIP-файл, скачанный из Studio. В терминале IDE появится сообщение: Library installed (библиотека установлена).

Инференс

Теперь пора провести настоящий тест. Инференс будем выполнять, полностью отключившись от Studio. Изменим один из примеров кода, созданных при развёртывании библиотеки Arduino.

В Arduino IDE откройте вкладку File/Examples, найдите свой проект и в примерах выберите Nicla_vision_fusion:

Обратите внимание: код, созданный Edge Impulse, использует подход слияния данных датчиков (sensor fusion), где применяются IMU (акселерометр и гироскоп) и ToF-датчик. В начале кода находятся библиотеки, связанные с нашим проектом: IMU и ToF:

/* Подключение библиотек ---------------------------------- */
#include <NICLA_Vision_Movement_Classification_inferencing.h>
#include <Arduino_LSM6DSOX.h> // IMU
#include "VL53L1X.h" // ToF

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

Вот и всё!

Теперь можно загрузить код на устройство и проводить инференс. Нажмите кнопку [RESET] на Nicla дважды, чтобы перевести её в режим загрузки (если она всё ещё подключена к Studio, отключите её), и загрузите скетч на плату.

Теперь попробуйте разные движения с платой (похожие на те, что вы записывали при сборе данных), наблюдая результат инференса каждого класса в Serial Monitor:

• Простой и погрузчик:

• Морская и наземная перевозка:

Обратите внимание, что во всех описанных ситуациях значение anomaly score было меньше 0,0. Попробуйте новое движение, которого не было в исходном наборе данных: например, «перекатывание» Nicla, когда камера направлена вниз — как контейнер, упавший с лодки, или даже авария на лодке:

• Обнаружение аномалии:

В этом случае аномалия гораздо больше — свыше 1,00.

Постобработка

Теперь, когда мы знаем, что модель работает и распознаёт движения, предлагаем изменить код, чтобы увидеть результат на NiclaV полностью автономно — отключённой от ПК и питающейся от батареи, пауэрбанка или отдельного источника питания 5 В.

Идея та же, что и в проекте KWS: при распознавании определённого движения зажигается определённый светодиод. Например, для наземной перевозки загорится зелёный светодиод, для морской — красный, для погрузчика — синий, а если движения нет (простой), все светодиоды выключены. Можно также добавить условие для обнаружения аномалии: например, использовать белый цвет (все светодиоды горят одновременно).

Итоги

Блокноты и код, использованные в этой практической работе, можно найти в репозитории GitHub.

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

Примеры применения

Промышленность и производство

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

Здравоохранение

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

Бытовая электроника

• Управление жестами: распознавание определённых движений для управления устройствами, например включение света взмахом руки.
• Игры: улучшение игрового опыта за счёт ввода, управляемого движениями.

Транспорт и логистика

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

Умные города и инфраструктура

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

Безопасность и наблюдение

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

Сельское хозяйство

• Мониторинг техники: отслеживание производительности и использования сельскохозяйственной техники.
• Анализ поведения животных: мониторинг движения скота для выявления признаков проблем со здоровьем или стресса.

Экологический мониторинг

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

Трёхмерный корпус для Nicla

Для реальных приложений, как было сказано выше, к устройству можно добавить корпус. Eoin Jordan из Edge Impulse разработал отличный носимый корпус для контроля здоровья человека и механизмов для семейства плат Nicla. Он работает с магнитом 10 мм, винтами M2 и ремешком 16 мм для сценариев использования, связанных со здоровьем человека и машин. Ссылка: Arduino Nicla Voice and Vision Wearable Case.

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

Ресурсы

• Код для Arduino

• Блокнот Google Colab: Edge Impulse Spectral Features Block

• Проект Edge Impulse

Обнаружение объектов

Промпт DALL·E 3: мультфильм в стиле 1940–1950-х: просторный промышленный склад. На первом плане конвейер с игрушечными колёсами и коробками. У колёс яркие жёлтые центры и чёрные шины, коробки — белые кубики с чередующимся чёрно-белым узором. В конце движущегося конвейера стоит ретро-робот с инструментами и датчиками, который старательно классифицирует и пересчитывает прибывающие колёса и коробки. Общая эстетика напоминает анимацию середины века с чёткими линиями и классической палитрой.

Обзор

Это продолжение работы с классификацией изображений на Nicla Vision: теперь мы изучаем обнаружение объектов (Object Detection).

Обнаружение объектов и классификация изображений

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

Но что будет, если кот прыгнет рядом с бокалом вина? Модель по-прежнему распознаёт только преобладающую категорию на изображении — полосатого кота:

А что, если на изображении нет доминирующей категории?

Модель совершенно неверно определяет это изображение как «ashcan» (мусорный ящик), возможно из-за цветовых оттенков.

Модель, которая использовалась во всех предыдущих примерах, — MobileNet, обученная на большом наборе данных ImageNet.

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

Такие модели гораздо сложнее и крупнее, например MobileNetV2 SSD FPN-Lite 320x320, обученная на наборе COCO. Эта предобученная модель обнаружения объектов умеет находить до 10 объектов на изображении и выдаёт ограничивающий прямоугольник (bounding box) для каждого обнаруженного объекта. Изображение ниже — результат работы такой модели на Raspberry Pi:

Модели для обнаружения объектов (такие как MobileNet SSD или YOLO) обычно занимают несколько мегабайт. Для Raspberry Pi это нормально, но для встраиваемых устройств, где ОЗУ обычно меньше 1 МБ, такие модели не подходят.

Инновационное решение для обнаружения объектов: FOMO

Edge Impulse представила в 2022 году FOMO (Faster Objects, More Objects) — новое решение для обнаружения объектов на встраиваемых устройствах. Оно работает не только на Nicla Vision (Cortex M7), но и на процессорах Cortex M4F (Arduino Nano33 и серии OpenMV M4), а также на устройствах Espressif ESP32 (ESP-CAM и XIAO ESP32S3 Sense).

В этой практической работе мы будем использовать FOMO для обнаружения объектов и не станем вдаваться в подробности самой модели. Чтобы больше узнать о её работе, можно прочитать официальное объявление FOMO от Edge Impulse, где Louis Moreau и Mat Kelcey подробно объясняют принцип работы.

Цель проекта обнаружения объектов

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

Иначе говоря, нам нужна многоклассовая классификация, где каждое изображение может относиться к трём классам:

• фон (объектов нет);
• коробка (Box);
• колесо (Wheel).

Вот несколько неразмеченных примеров изображений, по которым мы будем обнаруживать объекты (колёса и коробки):

Нас интересует, какой объект есть на изображении, его положение (центроид) и сколько таких объектов на нём присутствует. Размер объекта FOMO не определяет — в отличие от MobileNet SSD или YOLO, где ограничивающий прямоугольник является одним из выходных данных модели.

Проект мы будем разрабатывать с Nicla Vision для захвата изображений и инференса, а для машинного обучения использовать Edge Impulse Studio. Но прежде чем начинать проект обнаружения объектов в Studio, создадим сырой набор данных (без разметки) с изображениями, на которых есть объекты для обнаружения.

Сбор данных

Для съёмки изображений можно использовать:

• инструмент Web Serial Camera;
• Edge Impulse Studio;
• OpenMV IDE;
• смартфон.

Здесь мы будем использовать OpenMV IDE.

Сбор набора данных в OpenMV IDE

Сначала создаём на компьютере папку, в которую будут сохраняться данные, например «data». Затем в OpenMV IDE открываем Tools > Dataset Editor и выбираем New Dataset, чтобы начать сбор набора данных:

Edge Impulse рекомендует, чтобы объекты были похожего размера и не перекрывали друг друга, — так модель работает лучше. На промышленном предприятии это нормально: камера закреплена неподвижно и находится на одном расстоянии от объектов. Тем не менее мы попробуем и смешанные размеры и положения, чтобы посмотреть на результат.

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

Подключите Nicla Vision к OpenMV IDE и запустите dataset_capture_script.py. Нажатие кнопки Capture Image начнёт съёмку изображений:

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

Сохраняемые изображения имеют размер кадра QVGA $320\times 240$ и формат RGB565 (формат цветных пикселей).

Когда набор данных собран, закройте инструмент Dataset Editor через Tools > Dataset Editor.

Edge Impulse Studio

Настройка проекта

Откройте Edge Impulse Studio, войдите в систему по кнопке Login (или создайте аккаунт) и начните новый проект.

Здесь можно клонировать проект, созданный для этой практической работы: NICLA_Vision_Object_Detection.

На панели проекта Dashboard откройте Project info и выберите Bounding boxes (object detection), а в правом верхнем углу страницы выберите Target — Arduino Nicla Vision (Cortex-M7).

Загрузка неразмеченных данных

В Studio откройте вкладку Data acquisition и в разделе UPLOAD DATA загрузите с компьютера снятые файлы.

Можно поручить Studio автоматически разделить данные на обучающую и тестовую выборки или сделать это вручную.

Все неразмеченные изображения (51) загружены, но перед использованием в наборе данных их нужно правильно разметить. Для этого в Studio есть инструмент, который открывается по ссылке Labeling queue (51).

В бесплатной версии Edge Impulse Studio доступны два способа разметки с помощью ИИ:

• с использованием YOLOv5;
• отслеживанием объектов между кадрами.

Для клиентов Enterprise Edge Impulse запустила функцию автоматической разметки, которая упрощает разметку в проектах обнаружения объектов.

Обычные объекты можно быстро распознать и разметить с помощью готовой библиотеки предобученных моделей обнаружения YOLOv5 (обученных на наборе COCO). Но в нашем случае объектов нет в наборах COCO, поэтому выберем опцию tracking objects. С ней, как только вы нарисуете рамки и разметите изображения в одном кадре, объекты будут автоматически отслеживаться от кадра к кадру, и новые объекты будут частично размечены (не все — корректно).

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

Разметка набора данных

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

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

Затем просмотрите размеченные примеры на вкладке Data acquisition. Если какая-то метка неверна, её можно отредактировать через меню три точки после названия образца:

Studio подскажет, как заменить неверную метку и исправить набор данных.

Проектирование Impulse

На этом этапе нужно определить, как:

• Предобработка: изменить размер отдельных изображений с $320\times 240$ до $96\times 96$, сжав их к квадратной форме (без обрезки). Затем изображения переводятся из RGB в оттенки серого (Grayscale).

• Проектирование модели: в данном случае «Object Detection» (обнаружение объектов).

Предобработка всего набора данных

В этом разделе выберите Color depth — Grayscale, подходящий для моделей FOMO, и сохраните parameters.

Studio автоматически переходит к следующему разделу Generate features, где обрабатываются все образцы. В результате получается набор данных из отдельных изображений $96\times 96\times 1$, или 9 216 признаков.

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

Один из образцов (№ 46), судя по всему, находится не в том месте, но щелчок по нему подтверждает, что разметка верна.

Проектирование модели, обучение и тестирование

Мы будем использовать FOMO — модель обнаружения объектов на основе MobileNetV2 (альфа 0,35), которая грубо сегментирует изображение на сетку: фон и интересующие объекты (здесь коробки и колёса).

FOMO — инновационная модель машинного обучения для обнаружения объектов, которая может использовать в 30 раз меньше энергии и памяти, чем традиционные модели вроде Mobilenet SSD и YOLOv5. FOMO способна работать на микроконтроллерах с ОЗУ менее 200 КБ. Главная причина в том, что другие модели вычисляют размер объекта, рисуя вокруг него квадрат (ограничивающий прямоугольник), а FOMO не учитывает размер и выдаёт только информацию о том, где объект находится на изображении, — в виде координат его центроида.

Как работает FOMO

FOMO берёт изображение в оттенках серого и делит его на блоки пикселей с коэффициентом 8. Для входного изображения $96\times 96$ сетка будет $12\times 12$ $(96/8=12)$. Затем FOMO запускает классификатор для каждого блока пикселей, чтобы вычислить вероятность того, что в нём есть коробка или колесо, и определяет области с наибольшей вероятностью наличия объекта (если в блоке пикселей объектов нет, он классифицируется как background). По перекрытию итоговой области FOMO выдаёт координаты (относительно размеров изображения) центроида этой области.

Для обучения нужно выбрать предобученную модель. Используем FOMO (Faster Objects, More Objects) MobileNetV2 0.35. Эта модель занимает около 250 КБ ОЗУ и 80 КБ ПЗУ (флеш-памяти), что хорошо подходит для нашей платы, у которой 1 МБ ОЗУ и ПЗУ.

Гиперпараметры обучения такие:

• эпох: 60;
• размер батча (batch size): 32;
• скорость обучения (learning rate): 0,001.

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

В итоге модель получает F1-меру около 91 % (валидация) и 93 % (тестовые данные).

Обратите внимание: FOMO автоматически добавил третью метку background к двум заданным ранее (box и wheel).

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

Проверка модели в режиме «Live Classification»

Поскольку Edge Impulse официально поддерживает Nicla Vision, подключим её к Studio. Для этого выполните шаги:

• Скачайте последнюю прошивку EI и распакуйте её.

• Откройте ZIP-архив на компьютере и выберите загрузчик для своей ОС.

• Переведите Nicla Vision в режим загрузки, дважды нажав кнопку reset.

• Запустите пакетный файл для своей ОС, чтобы загрузить двоичный файл (arduino-nicla-vision.bin) на плату.

Откройте раздел Live classification в EI Studio и с помощью webUSB подключите Nicla Vision:

Когда подключение установлено, Nicla может снимать реальные изображения, которые обученная модель в Edge Impulse Studio будет тестировать.

Учтите, что модель может давать ложные срабатывания и пропуски. Это можно уменьшить, задав подходящий Confidence Threshold (порог уверенности; настройка через меню три точки). Попробуйте значение 0,8 и выше.

Развёртывание модели

На вкладке Deploy выберите OpenMV Firmware и нажмите [Build].

При повторном подключении Nicla к OpenMV IDE она попытается обновить свою прошивку. Вместо этого выберите опцию Load a specific firmware. Либо откройте меню Tools > Run Bootloader (Load Firmware).

На компьютере появится ZIP-файл из Studio. Откройте его:

Загрузите файл .bin на плату:

Когда загрузка завершится, появится всплывающее сообщение. Нажмите Press OK и откройте скрипт ei_object_detection.py, скачанный из Studio.

Примечание: если появится всплывающее окно с сообщением, что прошивка устарела, нажмите [NO], чтобы не обновлять её.

Перед запуском скрипта изменим несколько строк. Обратите внимание, что определение окна можно оставить как $240\times 240$, а камера может снимать изображения в формате QVGA/RGB. Снимок будет предобработан прошивкой, развёрнутой из Edge Impulse.

import sensor
import time
import ml
from ml.utils import NMS
import math
import image

sensor.reset()  # Сброс и инициализация датчика.
# Формат пикселей (RGB565 или GRAYSCALE)
sensor.set_pixformat(sensor.RGB565)
# Размер кадра QVGA (320x240)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)  # Даём камере настроиться.

Задайте минимальную уверенность, например 0,8, чтобы уменьшить количество ложных срабатываний и пропусков.

min_confidence = 0.8

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

threshold_list = [(math.ceil(min_confidence * 255), 255)]

# Загрузка встроенной модели
model = ml.Model("trained")
print(model)

# Вместо этого модели можно загрузить из
# файловой системы.
# model = ml.Model(
#     '<object_detection_modelwork>.tflite',
#     load_to_fb=True)
# labels = [line.rstrip('\n') for line in open("labels.txt")]

colors = [ # Добавьте цвета, если одновременно обнаруживаете более
           # 7 классов.
    (255, 255,   0), # background: жёлтый (не используется)
    (  0, 255,   0), # cube (коробка): зелёный
    (255,   0,   0), # wheel (колесо): красный
    (  0,   0, 255), # не используется
    (255,   0, 255), # не используется
    (  0, 255, 255), # не используется
    (255, 255, 255), # не используется
]

Остальной код оставьте без изменений:

# FOMO выдаёт изображение для каждого класса, где каждый пиксель —
# центроид обученного объекта. Поэтому мы получаем эти выходные
# изображения и запускаем на них find_blobs(), чтобы извлечь
# центроиды. Также запускаем get_stats() для найденных блобов,
# чтобы определить их оценку. Объект Non-Max-Suppression (NMS)
# затем отфильтровывает перекрывающиеся обнаружения и переносит
# их положение из выходного изображения обратно на исходное
# входное изображение. Функция возвращает список для каждого
# класса, в котором содержится список кортежей (rect, score),
# описывающих обнаруженные объекты.


def fomo_post_process(model, inputs, outputs):
    n, oh, ow, oc = model.output_shape[0]
    nms = NMS(ow, oh, inputs[0].roi)
    for i in range(oc):
        img = image.Image(outputs[0][0, :, :, i] * 255)
        blobs = img.find_blobs(
            threshold_list,
            x_stride=1,
            area_threshold=1,
            pixels_threshold=1,
        )
        for b in blobs:
            rect = b.rect()
            x, y, w, h = rect
            score = (
                img.get_statistics(
                    thresholds=threshold_list, roi=rect
                ).l_mean()
                / 255.0
            )
            nms.add_bounding_box(x, y, x + w, y + h, score, i)
    return nms.get_bounding_boxes()


clock = time.clock()
while True:
    clock.tick()

    img = sensor.snapshot()

    for i, detection_list in enumerate(
        model.predict([img], callback=fomo_post_process)
    ):
        if i == 0:
            continue  # класс background
        if len(detection_list) == 0:
            continue  # для этого класса нет обнаружений?

        print("********** %s **********" % model.labels[i])
        for (x, y, w, h), score in detection_list:
            center_x = math.floor(x + (w / 2))
            center_y = math.floor(y + (h / 2))
            print(f"x {center_x}\ty {center_y}\tscore {score}")
            img.draw_circle((center_x, center_y, 12), color=colors[i])

    print(clock.fps(), "fps", end="\n")

Затем нажмите зелёную кнопку Play, чтобы запустить код:

В поле зрения камеры видны объекты, центроиды которых отмечены кругами фиксированного размера 12 пикселей (каждый круг имеет свой цвет в зависимости от класса). В Serial Terminal модель выводит обнаруженные метки и их положение в окне изображения $(240\times 240)$.

Учтите, что начало координат находится в левом верхнем углу.

Частота кадров составляет около 8 кадров в секунду (примерно как в проекте классификации изображений). Это объясняется тем, что FOMO искусно построена на основе CNN-модели, а не модели обнаружения вроде SSD MobileNet или YOLO. Например, при запуске модели MobileNetV2 SSD FPN-Lite $320\times 320$ на Raspberry Pi 4 задержка примерно в 5 раз выше (около 1,5 кадра в секунду).

Короткое видео с результатами инференса:

Итоги

FOMO — важный скачок в области обработки изображений, как сказали Louis Moreau и Mat Kelcey при её запуске в 2022 году:

FOMO — революционный алгоритм, который впервые приносит обнаружение, отслеживание и подсчёт объектов в реальном времени на микроконтроллеры.

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

Ресурсы

• Проект Edge Impulse

Настройка

Промпт DALL·E 3: иллюстрация в духе мультфильма 1950-х годов, где плата Arduino NICLA VISION с камерой и другими датчиками стоит в центре старомодного стола. На экране компьютера со скруглёнными углами открыта Arduino IDE. Код связан с настройкой светодиодов и распознаванием голосовых команд. В Serial Monitor явно выводятся слова «yes» и «no».

Обзор

Arduino Nicla Vision (иногда её называют NiclaV) — отладочная плата с двумя процессорами, которые могут выполнять задачи параллельно. Она входит в семейство плат с тем же форм-фактором, но рассчитанных на конкретные задачи, например Nicla Sense ME и Nicla Voice. Платы Nicla хорошо справляются с эффективным выполнением процессов, созданных с помощью TensorFlow Lite. Например, одно ядро NiclaV на лету выполняет алгоритм компьютерного зрения (инференс), а другое решает низкоуровневые задачи: управляет мотором, обменивается данными или работает как пользовательский интерфейс. Встроенный беспроводной модуль позволяет одновременно использовать Wi-Fi и Bluetooth Low Energy (BLE).

Аппаратная часть

Два параллельных ядра

Центральный процессор — двухъядерный STM32H747: ядро Cortex-M7 работает на частоте 480 МГц, ядро Cortex-M4 — на 240 МГц. Два ядра обмениваются данными через механизм удалённого вызова процедур (RPC), который позволяет без затруднений вызывать функции на другом процессоре. Оба процессора используют общую периферию кристалла и могут запускать:

• скетчами Arduino поверх Arm Mbed OS;
• нативными приложениями Mbed;
• MicroPython и JavaScript через интерпретатор;
• TensorFlow Lite.

Память

Память важна для проектов встраиваемого машинного обучения. На плате NiclaV можно разместить до 16 МБ флеш-памяти QSPI для хранения данных. Но для инференса ML используется именно SRAM микроконтроллера: в STM32H747 её всего 1 МБ, и её делят оба процессора. Кроме того, в микроконтроллер встроено 2 МБ флеш-памяти, в основном для хранения кода.

Датчики

• Камера: цветная CMOS-камера GC2145 с разрешением 2 Мп.
• Микрофон: MP34DT05 — сверхкомпактный маломощный всенаправленный цифровой MEMS-микрофон с ёмкостным чувствительным элементом и интерфейсом.
• 6-осевой IMU: данные 3D-гироскопа и 3D-акселерометра от 6-осевого IMU LSM6DSOX.
• Датчик времени полёта (ToF): VL53L1CBV0FY добавляет точное измерение расстояния с малым энергопотреблением. Невидимый ближний инфракрасный лазер VCSEL (вместе с аналоговым драйвером) и приёмная оптика собраны в компактный модуль под камерой.

Установка Arduino IDE

Сначала подключите плату (micro USB) к компьютеру:

Установите ядро Mbed OS для плат Nicla в Arduino IDE. При открытой IDE перейдите в Tools > Board > Board Manager, найдите в поиске Arduino Nicla Vision и установите плату.

Затем откройте Tools > Board > Arduino Mbed OS Nicla Boards и выберите Arduino Nicla Vision. Когда плата подключена по USB, в списке портов появится Nicla — выберите её.

Откройте скетч Blink в разделе Examples/Basic и запустите его кнопкой Upload в IDE. Должен замигать встроенный светодиод (зелёный RGB). Это значит, что плата Nicla установлена правильно и работает!

Проверка микрофона

В Arduino IDE перейдите в Examples > PDM > PDMSerialPlotter, откройте скетч и запустите его. Откройте Plotter и посмотрите аудиосигнал с микрофона:

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

Проверка IMU

Перед проверкой IMU нужно установить библиотеку LSM6DSOX. Для этого откройте Library Manager и найдите LSM6DSOX. Установите библиотеку от Arduino:

Затем откройте Examples > Arduino_LSM6DSOX > SimpleAccelerometer и запустите тест акселерометра (можно также запустить тест гироскопа и температуры платы):

Проверка датчика ToF (времени полёта)

Как и в случае с IMU, нужно установить библиотеку VL53L1X ToF. Для этого откройте Library Manager и найдите VL53L1X. Установите библиотеку от Pololu:

Затем запустите скетч proximity_detection.ino:

В Serial Monitor вы увидите расстояние от камеры до объекта перед ней (максимум 4 м).

Проверка камеры

Камеру можно проверить, например, с помощью кода из раздела Examples > Camera > CameraCaptureRawBytes. Изображение мы напрямую не увидим, но сможем получить необработанные данные, которые формирует камера.

Чтобы увидеть изображение с камеры, можно воспользоваться Web Serial Camera (API). Это веб-приложение передаёт изображение с камеры по Web Serial с плат Arduino, оснащённых камерой.

Пример Web Serial Camera показывает, как передать данные изображения с платы Arduino и как распаковать их в JavaScript для отображения. Кроме того, в исходном коде веб-приложения есть примеры фильтров изображения, которые показывают, как изменять пиксельные данные для получения визуальных эффектов.

Скетч Arduino (CameraCaptureWebSerial) для передачи данных изображения находится здесь. Его также можно открыть в меню «Examples→Camera» Arduino IDE, если выбрана плата Nicla.

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

Установка OpenMV IDE

OpenMV IDE — ведущая интегрированная среда разработки для камер OpenMV, в том числе похожих на Nicla Vision. В ней есть мощный текстовый редактор, терминал для отладки и просмотрщик кадров с гистограммой. Камеру мы будем программировать на MicroPython.

Откройте страницу загрузки OpenMV IDE, скачайте версию для вашей операционной системы и установите её, следуя инструкциям.

IDE должна открыться с кодом helloworld_1.py в области редактирования. Если этого не произошло, откройте его через File > Examples > HelloWorld > helloworld.py.

Все сообщения, которые отправляются по последовательному соединению (через print() или сообщения об ошибках), во время работы отображаются в Serial Terminal. Изображение с камеры выводится в области Camera Viewer (или Frame Buffer), а гистограмма — сразу под ним, в области Histogram.

Обновление загрузчика

Прежде чем подключать Nicla к OpenMV IDE, убедитесь, что установлена последняя версия загрузчика. Откройте Arduino IDE, выберите плату Nicla и откройте скетч Examples > STM_32H747_System STM32H747_manageBootloader. Загрузите код на плату. Serial Monitor подскажет дальнейшие действия.

Установка прошивки

После обновления загрузчика переведите Nicla Vision в режим загрузчика, дважды нажав кнопку reset на плате. Встроенный зелёный светодиод начнёт плавно гаснуть и загораться. Теперь вернитесь в OpenMV IDE и нажмите значок подключения (левая панель инструментов):

Появится всплывающее окно, которое сообщит, что обнаружена плата в режиме DFU, и предложит выбрать дальнейшее действие. Сначала выберите Install the latest release firmware (vX.Y.Z). Это установит на Nicla Vision последнюю версию прошивки OpenMV.

Опцию Erase internal file system можно не выбирать, затем нажмите [OK].

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

Дождитесь, пока зелёный светодиод перестанет мигать и плавно менять яркость. По окончании процесса появится сообщение «DFU firmware update complete!». Нажмите [OK].

Когда Nicla Vision подключается к панели инструментов, появляется зелёная кнопка «Play».

Кроме того, на компьютере появится диск с именем «NO NAME».

Каждый раз, когда вы нажимаете кнопку [RESET] на плате, автоматически запускается сохранённый на ней скрипт main.py. Вы можете загрузить код main.py в IDE (File > Open File...).

Это код «Blink», он подтверждает, что аппаратная часть исправна.

Проверка камеры

Чтобы проверить камеру, запустим helloworld_1.py. Для этого выберите скрипт в File > Examples > HelloWorld > helloworld.py.

Когда вы нажмёте зелёную кнопку «Play», скрипт MicroPython (helloworld.py) из области редактирования загрузится и запустится на Nicla Vision. В области Camera Viewer начнётся потоковая передача видео. В Serial Monitor будет выводиться FPS (кадров в секунду): примерно 27 кадров/с.

Вот скрипт helloworld.py:

import sensor, time

sensor.reset()                      # Сброс и инициализация
                                    # датчика.
sensor.set_pixformat(sensor.RGB565) # Формат пикселей RGB565
                                    # (или GRAYSCALE)
sensor.set_framesize(sensor.QVGA)   # Размер кадра
                                    # QVGA (320x240)
sensor.skip_frames(time = 2000)     # Ожидание, пока
                                    # настройки вступят в силу.
clock = time.clock()                # Создание объекта часов
                                    # для отслеживания FPS.

while(True):
    clock.tick()                    # Обновление счётчика FPS.
    img = sensor.snapshot()         # Снимок и возврат
                                    # изображения.
    print(clock.fps())

Скрипты на Python, которые использовались здесь, можно найти на GitHub.

Код можно разделить на две части:

• Настройка: подключаются и инициализируются библиотеки, определяются и задаются переменные.

• Цикл: часть кода (цикл while), которая выполняется непрерывно. Снимается изображение (переменная img), то есть один кадр. Каждый кадр можно использовать для инференса в приложениях машинного обучения.

Чтобы остановить программу, нажмите красную кнопку [X].

Примечание: при подключении к IDE OpenMV Cam работает примерно вдвое медленнее. После отключения FPS должен вырасти.

Другие скрипты на Python можно найти в репозитории GitHub. Попробуйте проверить встроенные датчики.

Подключение Nicla Vision к Edge Impulse Studio

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

Edge Impulse официально поддерживает Nicla Vision. Поэтому сначала создайте новый проект в Studio и подключите Nicla к нему. Для этого выполните шаги:

• Скачайте Arduino CLI для вашей архитектуры компьютера (ОС).
• Скачайте самую свежую прошивку EI.
• Распакуйте оба архива и поместите все файлы в одну папку.
• Переведите Nicla Vision в режим загрузки, дважды нажав кнопку reset.
• Запустите загрузчик (прошивку EI), соответствующий вашей ОС:

• Пакетный скрипт для вашей ОС загрузит двоичный файл arduino-nicla-vision.bin на плату.

В Chrome для подключения Nicla к EI Studio можно использовать WebUSB. EI CLI не нужен.

Откройте свой проект в Studio, на вкладке Data Acquisition выберите WebUSB (1). Откроется окно; выберите вариант, в котором видно, что Nicla is paired (2), и нажмите [Connect] (3).

Какие данные датчика собирать, можно выбрать в разделе Collect Data на вкладке Data Acquisition.

Например, IMU data (inertial):

Или изображение (Camera):

Также можно проверить внешний датчик, подключённый к ADC (вывод 0 Nicla), и другие встроенные датчики: например, built-in microphone, ToF (Proximity) или комбинацию датчиков (fusion).

Расширение платы Nicla Vision (необязательно)

Иногда при прототипировании нужно поэкспериментировать с внешними датчиками и устройствами. Хорошее расширение для Nicla — Arduino MKR Connector Carrier (Grove compatible).

На плате 14 разъёмов Grove: пять одиночных аналоговых входов (A0–A5), один двойной аналоговый вход (A5/A6), пять одиночных цифровых входов/выходов (D0–D4), один двойной цифровой вход/выход (D5/D6), один I2C (TWI) и один UART (Serial). Все разъёмы совместимы с напряжением 5 В.

Учтите, что все 17 выводов Nicla Vision подключаются к разъёмам Grove расширения, но некоторые соединения Grove остаются неподключёнными.

Эта плата расширения совместима с MKR и может использоваться с Nicla Vision и Portenta.

Например, предположим, что в проекте TinyML нужно отправлять результаты инференса через устройство LoRaWAN и добавлять данные о локальной освещённости. При автономной работе часто рекомендуется локальный маломощный дисплей, например OLED. Такая схема показана ниже:

Датчик освещённости Grove подключается к одному из одиночных аналоговых выводов (A0/PC4), устройство LoRaWAN — к UART, а OLED-дисплей — к разъёму I2C.

Выводы Nicla 3 (Tx) и 4 (Rx) подключаются к разъёму Serial Shield. Обмен по UART используется для устройства LoRaWAN. Вот простой код для работы с UART:

# Тест UART — By: marcelo_rovai — Sat Sep 23 2023

import time
from pyb import UART
from pyb import LED

redLED = LED(1) # встроенный красный светодиод

# Инициализация объекта UART.
# UART Nicla Vision (выводы TX/RX) находится на «LP1»
uart = UART("LP1", 9600)

while(True):
    uart.write("Hello World!\r\n")
    redLED.toggle()
    time.sleep_ms(1000)

Чтобы проверить работу UART, подключите другое устройство, например Arduino UNO, которое выводит «Hello World» в Serial Monitor. Вот код.

Ниже приведён код «Hello World» для OLED с интерфейсом I2C. Драйвер OLED SSD1306 для MicroPython (ssd1306.py), созданный Adafruit, тоже нужно загрузить на Nicla (скрипт ssd1306.py можно найти на GitHub).

# Nicla_OLED_Hello_World — By: marcelo_rovai — Sat Sep 30 2023

# Сохраните на устройство драйвер OLED SSD1306 для MicroPython,
# интерфейсы I2C и SPI от Adafruit
import ssd1306

from machine import I2C
i2c = I2C(1)

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

oled.text('Hello, World', 10, 10)
oled.show()

Наконец, простой скрипт для чтения значения ADC на выводе «PC4» (вывод A0 Nicla):

# Датчик освещённости (A0) — By: marcelo_rovai — Wed Oct 4 2023

import pyb
from time import sleep

adc = pyb.ADC(pyb.Pin("PC4"))   # создание аналогового объекта
                                # из вывода
val = adc.read()                # чтение аналогового значения

while (True):

    val = adc.read()
    print ("Light={}".format (val))
    sleep (1)

Тот же ADC можно использовать и для других величин, например температуры.

Обратите внимание: приведённые выше скрипты (скачаны с GitHub) лишь показывают, как подключать внешние устройства к Nicla Vision с помощью MicroPython.

Итоги

Arduino Nicla Vision — отличное миниатюрное устройство для промышленного и профессионального применения! Оно мощное, надёжное, маломощное и имеет подходящие датчики для самых распространённых задач встраиваемого машинного обучения: зрения, движения, слияния данных датчиков и звука.

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

Ресурсы

• Коды на MicroPython

• Коды для Arduino

Обзор

Эти лабораторные работы дают уникальную возможность получить практический опыт работы с системами машинного обучения (ML). В отличие от работы с большими моделями, которым нужны ресурсы уровня дата-центра, эти упражнения позволяют напрямую работать с оборудованием и программным обеспечением с помощью TinyML. Такой практический подход даёт осязаемое понимание проблем и возможностей развёртывания ИИ, пусть и в небольшом масштабе. При этом принципы в целом те же, что и при работе с более крупными системами.

Где купить

Комплект XIAOML Kit включает плату XIAO ESP32S3 Sense, плату расширения с IMU, OLED-дисплеем и набором для работы с SD-картой:

• XIAOML Kit (Seeed Studio) (~$40)

Отдельные компоненты также доступны у Seeed Studio.

Предварительные требования

• Комплект XIAOML Kit:

  • плата XIAO ESP32S3 Sense;
  • плата расширения с 6-осевым IMU и 0,42-дюймовым OLED-дисплеем;
  • набор для работы с SD-картой:
    • SD-карта и адаптер USB для хранения данных;
    • кабель USB-C для подключения платы к компьютеру.

• Сеть: доступ в интернет для загрузки необходимого программного обеспечения.

Настройка

• Настройка комплекта XIAOML Kit

Упражнения

Классификация изображений

Промпт DALL·E: иллюстрация в стиле мультфильма 1950-х, основанная на реальном изображении Marcelo Rovai

Обзор

Мы всё чаще сталкиваемся с революцией искусственного интеллекта (ИИ), и, как утверждает Gartner, Edge AI и компьютерное зрение обладают очень высоким потенциалом влияния, и это уже сейчас!

Когда мы смотрим на машинное обучение (ML) применительно к зрению, первое понятие, с которым мы сталкиваемся, — классификация изображений, своего рода «Hello World» для ML: простая и вместе с тем глубокая задача!

XIAOML Kit от Seeed Studio — комплексное аппаратное решение на основе XIAO ESP32-S3 Sense со встроенной камерой OV3660 и поддержкой SD-карт. Эти возможности делают XIAO ESP32S3 Sense отличной отправной точкой для знакомства с компьютерным зрением на базе TinyML.

В этой лабораторной работе мы разберём классификацию изображений с помощью инструмента SenseCraft AI, не требующего написания кода, а затем более подробно рассмотрим разработку с Edge Impulse Studio и Arduino IDE.

Цели обучения

• Развёртывание предобученных моделей с помощью SenseCraft AI Studio для быстрых приложений компьютерного зрения;
• Сбор и управление наборами изображений для собственных задач классификации с правильной организацией данных;
• Обучение собственных моделей классификации изображений методом переноса обучения (transfer learning) с архитектурой MobileNet V2;
• Оптимизация моделей для развёртывания на периферии с помощью квантизации и экономной по памяти предобработки;
• Реализация конвейеров постобработки, включая управление GPIO и интеграцию инференса в реальном времени;
• Сравнение подходов к разработке без кода и с помощью продвинутых платформ ML для встраиваемых приложений.

Классификация изображений

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

Классификация изображений важна во многих областях: от организации и поиска по большим базам изображений в цифровых библиотеках и социальных сетях до помощи автономным системам в понимании окружения. Среди архитектур, которые существенно продвинули эту область, — свёрточные нейронные сети (CNN), например AlexNet, VGGNet и ResNet. Эти модели показали впечатляющую точность на сложных наборах данных, таких как ImageNet, выучивая иерархические представления визуальных данных.

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

Классификация изображений в рабочем пространстве SenseCraft AI

Сначала подключите XIAOML Kit (или только XIAO ESP32S3 Sense, отсоединённую от платы расширения) к компьютеру через USB-C, затем откройте рабочее пространство SenseCraft AI и подключите устройство.

После подключения выберите опцию [Select Model...] и введите в строке поиска: «Person Classification». Из доступных вариантов выберите модель, обученную на MobileNet V2 (при наведении курсора на модели открывается всплывающее окно с их основными характеристиками).

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

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

После успешной загрузки модели в области Preview мы увидим видеопоток с камеры XIAO и результат классификации (Person или Not a Person), а в Device Logger — подробности инференса.

Также можно выбрать интервал кадров инференса — от «Real-Time» (по умолчанию) до 10 секунд, а также режим передачи данных (UART, I2C и др.) — данные передаются устройством (по умолчанию UART через USB).

В Device Logger видно, что задержка модели составляет от 52 до 78 мс на предобработку и около 532 мс на инференс. Итого выходит чуть меньше 600 мс, или примерно 1,7 кадра в секунду (FPS).

Для работы MobileNet V2 0.35 XIAO потребляла пиковый ток 160 мА при напряжении 5,23 В, что даёт энергопотребление 830 мВт.

Постобработка

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

В SenseCraft AI это делается в разделе Output -> GPIO. Нажмите значок «Add», чтобы запускать действие при выполнении условий события. Откроется всплывающее окно, где можно задать нужное действие. Например, если человек обнаружен с уверенностью более 60 %, внутренний светодиод LED должен включаться. В реальном сценарии для запуска реле, которое включит свет, использовали бы GPIO, например D0, D1, D2, D11 или D12.

После подтверждения появится созданное Trigger Action (триггерное действие). Нажмите Send, чтобы отправить команду на XIAO.

Теперь, если направить XIAO на человека, внутренний светодиод загорится.

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

Проект классификации изображений

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

В SenseCraft AI Studio откройте вкладку Training:

По умолчанию обучается модель Classification с веб-камерой, если она доступна. Выберем вместо этого XIAOESP32S3 Sense. Нажатие зелёной кнопки [Connect] откроет всплывающее окно. Выберите соответствующий порт и нажмите синюю кнопку [Connect].

Изображение с камеры отобразится в области предпросмотра.

Цель

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

Смоделируем эту задачу: будем классифицировать игрушечную коробку (box) и игрушечное колесо (wheel). Также добавим третий класс изображений — фон (background), на котором в кадре нет объектов.

Сбор данных

Создадим классы, например в алфавитном порядке:

• Класс 1: background (фон);
• Класс 2: box (коробка);
• Класс 3: wheel (колесо).

Выберите один из классов и удерживайте зелёную кнопку (Hold to Record) под областью предпросмотра. Собранные изображения (и их количество) появятся на экране образцов. Аккуратно и медленно перемещайте камеру, чтобы снять объект с разных ракурсов. Чтобы поменять положение объекта или помешать съёмке, отпустите зелёную кнопку, переставьте объект и снова удерживайте её, чтобы продолжить съёмку.

После съёмки просмотрите изображения и удалите неверные.

Соберите около 50 изображений из каждого класса и переходите к этапу обучения.

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

Обучение

Убедитесь, что выбрано правильное устройство (XIAO ESP32S3 Sense), и нажмите [Start Training].

Тест

После обучения можно просмотреть результат инференса.

Учтите, что модель не работает на устройстве. Мы лишь снимаем изображения устройством и выполняем предварительный просмотр в реальном времени, используя обучаемую модель, которая работает в Studio.

Теперь пора по-настоящему развернуть модель на устройстве.

Развёртывание

В окне Supported Devices выберите обученную модель и XIAO ESP32S3 Sense, затем нажмите [Deploy to device].

SenseCraft AI перенаправит нас на вкладку Vision Workplace. Подтвердите развёртывание (Confirm), выберите порт и подключите устройство (Connect).

Модель будет записана в устройство. После автоматической перезагрузки модель начнёт работать на устройстве. В Device Logger видно, что задержка инференса составляет примерно 426 мс, плюс около 110 мс на предобработку, что соответствует частоте кадров 1,8 кадра в секунду (FPS).

Также в Settings можно настроить уверенность модели.

Для работы модели классификации изображений XIAO ESP32S3 потребляла пиковый ток 140 мА при напряжении 5,23 В, что даёт энергопотребление 730 мВт.

Как и раньше, в разделе Output –> GPIO можно включать GPIO или внутренний светодиод в зависимости от обнаруженного класса. Например, светодиод загорится, когда обнаружено колесо.

Сохранение модели

Модель можно сохранить в SenseCraft AI Studio. Studio сохранит все наши модели для последующего развёртывания. Для этого вернитесь на вкладку Training и нажмите кнопку [Save to SenseCraft]:

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

Обратите внимание: обученную модель (Int8 MobileNet V2 размером 320 КБ) можно скачать для дальнейшего использования или анализа, например с помощью Netron. Модель использует изображения размером $224\times 224\times 3$ в качестве входного тензора. На следующем шаге мы применим другие гиперпараметры в Edge Impulse Studio.

Модель также можно развернуть на устройстве повторно в любой момент. Рабочее пространство Workspace откроется в SenseCraft AI автоматически.

Проект классификации изображений на основе набора данных

Основная цель нашего проекта — обучить модель и выполнить инференс на XIAO ESP32S3 Sense. Для обучения нужно найти данные (на самом деле огромное количество данных!).

Но, как мы уже знаем, прежде всего нужна цель! Что мы хотим классифицировать?

С TinyML — набором методов, связанных с инференсом моделей машинного обучения на встраиваемых устройствах, — классификацию следует ограничивать тремя-четырьмя категориями из-за ограничений, главным образом по памяти. Например, можно обучить модель на снятых изображениях «коробка против колеса»; их можно скачать из SenseCraft AI Studio.

Также можно использовать совершенно новый набор данных, например с различением яблок, бананов и картофеля или других категорий. По возможности найдите специализированный набор данных с изображениями этих категорий. Хорошим началом будет Kaggle fruit-and-vegetable-image-recognition.

Загрузим набор данных, собранный в предыдущем разделе. Откройте меню (три точки) для каждого снятого класса и выберите Export Data.

Набор данных будет загружен на компьютер в виде ZIP-файла: по одному файлу на каждый класс. Сохраните их в рабочую папку и распакуйте. У вас должны появиться три папки — по одной на каждый класс.

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

Обучение модели в Edge Impulse Studio

Для обучения модели мы будем использовать Edge Impulse Studio. Edge Impulse — ведущая платформа разработки машинного обучения для периферийных устройств.

Войдите в аккаунт Edge Impulse (или создайте бесплатный) и создайте новый проект.

Сбор данных

Перейдите в раздел Data acquisition и выберите + Add data. Появится всплывающее окно. Выберите UPLOAD DATA.

После выбора появится новое всплывающее окно с запросом на обновление данных.

• В режиме загрузки (Upload mode) выберите select a folder и нажмите [Choose Files].
• Перейдите в папку, которая содержит один из классов, и нажмите [Upload].

• Вы автоматически вернётесь в окно Upload data.
• Выберите Automatically split between training and testing.
• Введите метку изображений, которые находятся в папке.
• Выберите [Upload data].
• Файлы начнут загружаться. После этого появится другое всплывающее окно с вопросом, создаёте ли вы проект обнаружения объектов. Выберите [no].

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

Закройте окно Upload Data и вернитесь на страницу Data acquisition. Мы видим, что весь набор загружен. На верхней панели видно 158 элементов, распределённых поровну. Также 19 % изображений оставлены для тестирования.

Проектирование Impulse

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

Классификация изображений — самое распространённое применение глубокого обучения, но для этой задачи нужен большой объём данных. У нас около 50 изображений на каждую категорию. Достаточно ли этого? Совсем нет! Чтобы «научить» модель различать каждый класс, нужны тысячи изображений. Однако эту проблему можно решить, дообучив уже обученную модель на наших данных. Этот приём называется «переносом обучения» (Transfer Learning, TL). С TL можно дообучить предобученную модель классификации изображений на наших данных, добиваясь хорошей производительности даже на относительно небольших наборах изображений, как в нашем случае.

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

Итак, начиная с сырых изображений, изменим их размер $(96\times 96)$ пикселей и передадим в блок Transfer Learning. Создадим Impulse.

На этом этапе можно также задать целевое устройство, чтобы контролировать «бюджет» (память и задержку). XIAO ESP32S3 официально не поддерживается Edge Impulse, поэтому рассмотрим Espressif ESP-EYE: он похож, но медленнее.

Сохраните Impulse, как показано выше, и перейдите в раздел Image.

Предобработка (генерация признаков)

Помимо изменения размера изображений, их можно перевести в оттенки серого или сохранить исходную глубину цвета RGB. Выберем [RGB] в разделе Image. Тогда каждый образец будет иметь размерность 27 648 признаков ($96\times 96\times 3$). Нажатие [Save Parameters] откроет новую вкладку Generate Features. Нажмите кнопку [Generate Features], чтобы создать признаки.

Проектирование модели, обучение и тестирование

В 2017 году Google представил MobileNetV1. В 2018 году вышла MobileNetV2: Inverted Residuals and Linear Bottlenecks, а в 2019-м — V3. MobileNet — семейство универсальных нейронных сетей для компьютерного зрения, специально созданных для мобильных устройств и поддерживающих классификацию, обнаружение и другие задачи. MobileNet — компактные модели с малой задержкой и низким энергопотреблением, параметры которых подобраны под ограничения ресурсов разных сценариев.

Хотя базовая архитектура MobileNet уже компактна и быстра, конкретному приложению часто нужна ещё более маленькая и быстрая модель. MobileNet вводит простой параметр α (альфа), называемый множителем ширины (width multiplier), для построения меньших и менее требовательных к вычислениям моделей. Роль множителя ширины α — равномерно «утончить» сеть на каждом слое.

В Edge Impulse Studio доступны MobileNet V1 (изображения $96\times 96$) и V2 (изображения $96\times 96$ и $160\times 160$) с несколькими значениями α (от 0,05 до 1,0). Например, наибольшая точность достигается у V2 с изображениями $160\times 160$ и α=1,0. Конечно, есть компромисс: чем выше точность, тем больше памяти (около 1,3 МБ ОЗУ и 2,6 МБ ПЗУ) нужно для работы модели и тем выше задержка. Наименьший объём — у MobileNet V1 с α=0,10 (около 53,2 КБ ОЗУ и 101 КБ ПЗУ).

Мы будем использовать MobileNet V2 0.35 как базовую модель (но можно выбрать модель с большим α). Последний слой нашей модели, предшествующий выходному, будет содержать 16 нейронов с 10 %-ным dropout для предотвращения переобучения.

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

Заглянем «под капот» и посмотрим, как Edge Impulse реализует политику аугментации данных:

# Реализация политики аугментации данных
def augment_image(image, label):
    # Случайно отражаем изображение по горизонтали
    image = tf.image.random_flip_left_right(image)

    # Увеличиваем размер изображения, затем случайно обрезаем его до
    # исходных размеров
    resize_factor = random.uniform(1, 1.2)
    new_height = math.floor(resize_factor * INPUT_SHAPE[0])
    new_width = math.floor(resize_factor * INPUT_SHAPE[1])
    image = tf.image.resize_with_crop_or_pad(image, new_height,
                                             new_width)
    image = tf.image.random_crop(image, size=INPUT_SHAPE)

    # Меняем яркость изображения
    image = tf.image.random_brightness(image, max_delta=0.2)

    return image, label

Теперь определим гиперпараметры:

• эпох: 20;
• размер батча (batch size): 32;
• скорость обучения (learning rate): 0,0005;
• размер валидационной выборки: 20 %.

Результат обучения:

Профиль модели предсказывает 233 КБ ОЗУ и 546 КБ флеш-памяти, что не создаёт проблем для XIAO ESP32S3, у которой 8 МБ PSRAM. Кроме того, Studio показывает задержку около 1160 мс, что очень много. Однако этого и следовало ожидать: мы используем ESP-EYE, у которого процессор Xtensa LX6, тогда как ESP32S3 использует более новый и мощный Xtensa LX7.

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

Развёртывание модели

Обученную модель можно развернуть:

• как .TFLITE для использования в SenseCraft AI;
• как Arduino Library в Edge Impulse Studio.

Начнём с SenseCraft, это проще и интуитивнее.

Развёртывание модели в SenseCraft AI

На Dashboard можно скачать обученную модель в нескольких форматах. Скачаем TensorFlow Lite (int8 quantized) размером 623 КБ.

В SenseCraft AI Studio откройте вкладку Workspace, выберите XIAO ESP32S3, соответствующий порт и подключите устройство.

Вы увидите последнюю модель, загруженную на устройство. Нажмите зелёную кнопку [Upload Model]. Появится всплывающее окно с запросом названия модели, файла модели и названий классов (объектов). Используем метки в алфавитном порядке: 0: background, 1: box и 2: wheel, затем нажмите [Send].

Через несколько секунд модель будет загружена («прошита») на устройство, и изображение с камеры появится в реальном времени в области Preview. Результат классификации будет показан под предпросмотром. В Settings с помощью курсора можно выбрать Confidence Threshold (порог уверенности) инференса.

В Device Logger в Serial Monitor видно задержку: около 81 мс на предобработку и 205 мс на инференс, что соответствует 3,4 кадра в секунду (FPS). Это вдвое больше, чем мы получили при обучении модели в SenseCraft, потому что здесь используются изображения меньшего размера ($96\times 96$ против $224\times 224$).

Общая задержка примерно в 4 раза меньше, чем оценка в Edge Impulse Studio для процессора Xtensa LX6; теперь инференс выполняется на процессоре Xtensa LX7.

Постобработка

Результат инференса модели, включая задержку, ID класса и уверенность, можно получить, как показано в Device Logger в SenseCraft AI. Это позволяет использовать XIAO ESP32S3 Sense как ИИ-датчик. Иначе говоря, данные модели можно получать по разным протоколам связи, таким как MQTT, UART, I2C или SPI, в зависимости от требований проекта.

Идея похожа на то, что мы делали в лабораторной работе по классификации изображений для Seeed Grove Vision AI V2 (раздел «Постобработка»).

Ниже пример подключения по шине I2C.

Подробнее см. вики Seeed Studio.

Развёртывание как библиотеки Arduino в EI Studio

На вкладке Deploy в Edge Impulse Studio выберите Arduino library, TensorFlow Lite, Quantized(int8) и нажмите [Build]. Обученная модель будет скачана как ZIP-библиотека Arduino:

Откройте Arduino IDE, в меню Sketch выберите Include Library и Add .ZIP Library. Затем укажите файл, скачанный из Edge Impulse Studio, и нажмите [Open].

Перейдите в Examples в Arduino IDE и найдите проект по имени (в данном случае: «Box_versus_Wheel_…Interfering»). Откройте esp32 → esp32_camera. Скетч esp32_camera.ino появится в IDE.

Этот скетч создан для обычной платы ESP32 и не будет работать с XIAO ESP32S3 Sense. Его нужно изменить. Скачайте изменённую версию из репозитория проекта на GitHub: Image_class_XIAOML-Kit.ino.

Разбор кода классификации изображений для XIAO ESP32S3

Код снимает изображения со встроенной камеры, обрабатывает их и классифицирует (в данном случае «Box», «Wheel» или «Background») с помощью модели, обученной в EI Studio. Он работает непрерывно и выполняет инференс в реальном времени на периферийном устройстве.

Коротко:

Камера → изображение JPEG → преобразование в RGB888 → изменение размера до $96\times 96$ → нейронная сеть → результаты классификации → вывод в последовательный порт

Основные компоненты

1. Подключение библиотек и зависимостей

#include <Box_versus_Wheel_-_XIAO_ESP32S3_inferencing.h>
#include "edge-impulse-sdk/dsp/image/image.hpp"
#include "esp_camera.h"

• Библиотека инференса Edge Impulse: содержит нашу обученную модель и движок инференса;
• Обработка изображений: предоставляет функции для работы с изображениями;
• ESP Camera: аппаратный интерфейс модуля камеры.

2. Конфигурации выводов камеры

Плата XIAO ESP32S3 Sense может работать с разными сенсорами камеры (OV2640 или OV3660), у которых могут быть разные конфигурации выводов. Код задаёт три возможные конфигурации:

// Конфигурация 1: наиболее распространённая конфигурация OV2640
#define CONFIG_1_XCLK_GPIO_NUM    10
#define CONFIG_1_SIOD_GPIO_NUM    40
#define CONFIG_1_SIOC_GPIO_NUM    39
// ... остальные выводы

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

3. Настройки управления памятью

#define EI_CAMERA_RAW_FRAME_BUFFER_COLS   320
#define EI_CAMERA_RAW_FRAME_BUFFER_ROWS   240
#define EI_CLASSIFIER_ALLOCATION_HEAP      1

• Размер буфера кадра: задаёт размер исходного изображения ($320\times 240$ пикселей);
• Выделение в куче (heap): используется динамическое выделение памяти для гибкости;
• Поддержка PSRAM: у ESP32S3 есть 8 МБ PSRAM для хранения больших данных, например изображений.

setup() — инициализация

void setup() {
    Serial.begin(115200);
    while (!Serial);

    if (ei_camera_init() == false) {
        ei_printf("Failed to initialize Camera!\r\n");
    } else {
        ei_printf("Camera initialized\r\n");
    }

    ei_sleep(2000);  // Ждём 2 секунды перед запуском
}

Эта функция:

1. Инициализирует последовательную связь для отладочного вывода;
2. Инициализирует камеру с автоматическим определением конфигурации;
3. Ждёт 2 секунды перед началом непрерывного инференса.

loop() — главный цикл обработки

Цикл выполняет следующие шаги непрерывно:

Шаг 1. Выделение памяти

snapshot_buf = (uint8_t*)ps_malloc(EI_CAMERA_RAW_FRAME_BUFFER_COLS *
                                   EI_CAMERA_RAW_FRAME_BUFFER_ROWS *
                                   EI_CAMERA_FRAME_BYTE_SIZE);

Выделяет память под буфер изображения, предпочтительно в PSRAM (более быстрой внешней ОЗУ), а при необходимости — в обычной куче.

Шаг 2. Захват изображения

if (ei_camera_capture((size_t)EI_CLASSIFIER_INPUT_WIDTH,
                     (size_t)EI_CLASSIFIER_INPUT_HEIGHT,
                     snapshot_buf) == false) {
    ei_printf("Failed to capture image\r\n");
    free(snapshot_buf);
    return;
}

Снимает изображение с камеры и сохраняет его в буфер.

Шаг 3. Запуск инференса

ei_impulse_result_t result = { 0 };
EI_IMPULSE_ERROR err = run_classifier(&signal, &result, false);

Запускает модель машинного обучения на снятом изображении.

Шаг 4. Вывод результатов

for (uint16_t i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
    ei_printf("  %s: %.5f\r\n",
              ei_classifier_inferencing_categories[i],
              result.classification[i].value);
}

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

ei_camera_init() — интеллектуальная инициализация камеры

Эта функция реализует интеллектуальную последовательность инициализации:

bool ei_camera_init(void) {
    // Пробуем конфигурацию 1 (распространённая для OV2640)
    update_camera_config(1);
    esp_err_t err = esp_camera_init(&camera_config);
    if (err == ESP_OK) goto camera_init_success;

    // Пробуем конфигурацию 2 (OV3660)
    esp_camera_deinit();
    update_camera_config(2);
    err = esp_camera_init(&camera_config);
    if (err == ESP_OK) goto camera_init_success;

    // Продолжаем пробовать другие конфигурации...
}

Функция:

1. Пробует несколько конфигураций выводов;
2. Проверяет разные тактовые частоты (10 МГц или 16 МГц);
3. Сначала пытается использовать PSRAM, затем переходит на DRAM;
4. Применяет настройки сенсора в зависимости от обнаруженного оборудования.

ei_camera_capture() — конвейер обработки изображений

bool ei_camera_capture(uint32_t img_width, uint32_t img_height, uint8_t *out_buf) {
    // 1. Получаем кадр с камеры
    camera_fb_t *fb = esp_camera_fb_get();

    // 2. Преобразуем JPEG в формат RGB888
    bool converted = fmt2rgb888(fb->buf, fb->len, PIXFORMAT_JPEG, snapshot_buf);

    // 3. Возвращаем буфер кадра драйверу камеры
    esp_camera_fb_return(fb);

    // 4. При необходимости меняем размер
    if (do_resize) {
        ei::image::processing::crop_and_interpolate_rgb888(...);
    }
}

Функция:

1. Снимает JPEG-изображение с камеры;
2. Преобразует его в формат RGB888 (требуется моделью машинного обучения);
3. Изменяет размер изображения под входной размер модели ($96\times 96$ пикселей).

Инференс

• Загрузите код на XIAO ESP32S3 Sense.

⚠️ Внимание

• На XIAO ESP32S3 ОБЯЗАТЕЛЬНО должна быть включена PSRAM. Проверить это можно в верхнем меню Arduino IDE: Tools → PSRAM:OPI PSRAM;
• Пакет поддержки плат (esp32 by Espressif Systems) должен быть версии 2.0.17. Не обновляйте его.

• Откройте Serial Monitor.
• Наведите камеру на объекты и проверьте результат в Serial Monitor.

Постобработка

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

Маленький 0,42-дюймовый OLED-дисплей XIAOML Kit ($72\times 40$ пикселей) становится важным компонентом постобработки: он превращает сырые результаты инференса в понятную человеку обратную связь — выводит названия классов и уровни уверенности прямо на устройстве. Это исключает необходимость во внешних мониторах и позволяет создавать по-настоящему автономные периферийные ИИ-системы в промышленности, сельском хозяйстве или розничной торговле, где мгновенное визуальное подтверждение предсказаний ИИ особенно важно.

Теперь изменим скетч так, чтобы он автоматически адаптировался к модели, обученной в Edge Impulse: он будет читать названия классов и их количество прямо из модели. На дисплее будут показываться сокращённые названия классов (по 3 буквы) крупным шрифтом для лучшей читаемости на маленьком дисплее $72\times 40$ пикселей. Скачайте код с GitHub: XIAOML-Kit-Img_Class_OLED_Gen.

Запустим код и посмотрим результат:

Итоги

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

• SenseCraft AI Studio даёт доступную отправную точку с интерфейсом без кода, позволяя быстро создавать прототипы и развёртывать предобученные модели, например для распознавания людей. С инференсом в реальном времени и встроенными средствами постобработки она показывает, как ИИ можно развернуть без глубоких знаний программирования или ML.

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

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

Работа демонстрирует фундаментальные принципы TinyML, которые выходят за рамки конкретного оборудования: инференс при ограниченных ресурсах, требования к обработке в реальном времени и полный путь от сбора данных через развёртывание модели до практических применений. Благодаря встроенным средствам постобработки, включая управление GPIO и протоколы связи, XIAO становится не просто движком инференса, а полноценной платформой ИИ-датчика.

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

Ресурсы

• Начало работы с XIAO ESP32S3
• SenseCraft AI Studio
• Рабочее пространство SenseCraft Vision
• Пример набора данных
• Проект Edge Impulse
• XIAO как ИИ-датчик
• Библиотека Seeed Arduino SSCMA
• Код XIAOML Kit

Распознавание ключевых слов (KWS)

Промпт DALL·E: иллюстрация в стиле мультфильма 1950-х на основе реального изображения Marcelo Rovai

Обзор

Распознавание ключевых слов (Keyword Spotting, KWS) — неотъемлемая часть многих систем распознавания речи: оно позволяет устройствам реагировать на определённые слова или фразы. Эта технология лежит в основе популярных устройств вроде Google Assistant или Amazon Alexa, но она в равной мере применима и достижима на небольших маломощных устройствах. Эта лабораторная работа проведёт вас через реализацию системы KWS с помощью TinyML на отладочной плате XIAO ESP32S3.

XIAO ESP32S3 с чипом ESP32-S3 от Espressif — компактный и мощный микроконтроллер с двухъядерным процессором Xtensa LX7, встроенными Wi-Fi и Bluetooth. Сочетание вычислительной мощности, энергоэффективности и гибкой связи делает его отличной платформой для приложений TinyML. Кроме того, благодаря плате расширения Sense у нас будет доступ к «sense»-части устройства, на которой есть камера, слот для SD-карты и цифровой микрофон. Встроенный микрофон и SD-карта будут ключевыми в этом проекте.

Мы будем использовать Edge Impulse Studio — мощную и удобную платформу, которая упрощает создание моделей машинного обучения и их развёртывание на периферийных устройствах. Мы шаг за шагом обучим модель KWS, оптимизируем её и развернём на XIAO ESP32S3 Sense.

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

Опираясь на опыт работы с TensorFlow Lite для микроконтроллеров (движок «под капотом» EI Studio), мы создадим систему KWS, способную выполнять машинное обучение в реальном времени прямо на устройстве.

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

Цели обучения

• Понять архитектуру голосового помощника, включая каскадные системы обнаружения и роль распознавания ключевых слов на периферии как первого этапа конвейеров обработки голоса;
• Освоить методы сбора аудиоданных: офлайн (микрофон XIAO ESP32S3 с записью на SD-карту) и онлайн (смартфон и Edge Impulse Studio);
• Реализовать цифровую обработку сигналов для аудио: основы протокола I2S, дискретизацию аудио 16 кГц/16 бит и преобразование сигналов из временной области в признаки частотной области с помощью MFCC;
• Обучить свёрточные нейронные сети для классификации аудио методом переноса обучения, с приёмами аугментации данных и оптимизацией модели для классификации по четырём классам (YES, NO, NOISE, UNKNOWN);
• Развернуть оптимизированные модели на микроконтроллерах с квантизацией (INT8), управлением памятью через PSRAM и оптимизацией инференса в реальном времени для встраиваемых систем;
• Создать полные конвейеры постобработки, включая пороги уверенности, управление GPIO для внешних устройств, интеграцию OLED-дисплея и создание автономных ИИ-датчиков;
• Сравнить способы разработки на платформах без кода (Edge Impulse Studio) и в традиционном программировании встраиваемых систем (Arduino IDE) для приложений TinyML.

Проект KWS

Как работает голосовой помощник?

Распознавание ключевых слов (KWS) критически важно для многих голосовых помощников: оно позволяет устройствам реагировать на определённые слова или фразы. Для начала важно понять, что голосовые помощники на рынке, например Google Home или Amazon Echo Dot, реагируют на человека, только когда их «будят» определённые ключевые слова: «Hey Google» в первом случае и «Alexa» во втором.

Иначе говоря, распознавание голосовых команд основано на многоступенчатой модели, или каскадном обнаружении (Cascade Detection).

Этап 1: маленький микропроцессор внутри Echo Dot или Google Home постоянно слушает звук и ждёт, когда будет распознано ключевое слово. Для такого обнаружения на периферии используется модель TinyML (приложение KWS).

Этап 2: данные отправляются в облако и обрабатываются более крупной моделью, только если приложение KWS на этапе 1 сработало.

В видео ниже показан пример: я эмулирую Google Assistant на Raspberry Pi (этап 2), а в роли устройства TinyML (этап 1) используется Arduino Nano 33 BLE.

Если хотите глубже изучить весь проект, см. моё руководство: Building an Intelligent Voice Assistant From Scratch.

В этой лабораторной работе мы сосредоточимся на этапе 1 (KWS, или Keyword Spotting), где используем XIAO ESP32S3 Sense с цифровым микрофоном для распознавания ключевого слова.

Конвейер инференса

Схема ниже показывает, как должно работать итоговое приложение KWS (во время инференса):

Наше приложение KWS будет распознавать четыре класса звуков:

• YES (ключевое слово 1);
• NO (ключевое слово 2);
• NOISE (ключевых слов нет, есть только фоновый шум);
• UNKNOWN (смесь слов, отличных от YES и NO).

Для реальных проектов всегда рекомендуется включать в набор не только ключевые слова, но и другие слова и звуки, например «Noise» (шум или фон) и «Unknown» (неизвестные слова).

Рабочий процесс машинного обучения

Главный компонент приложения KWS — его модель. Поэтому нужно обучить модель на наших ключевых словах, шуме и других словах («unknown»):

Набор данных

Критически важный компонент рабочего процесса машинного обучения — набор данных. Выбрав конкретные ключевые слова (YES и NO), мы можем воспользоваться набором данных, который разработал Пит Уорден (Pete Warden): «Speech Commands: A Dataset for Limited-Vocabulary Speech Recognition». В этом наборе 35 ключевых слов (по более чем 1000 образцов каждого), например yes, no, stop и go. То есть для yes и no можно получить по 1500 образцов.

Небольшую часть набора данных можно скачать из Edge Impulse Studio (готовый набор данных для распознавания ключевых слов). Он включает образцы четырёх классов, которые мы будем использовать в проекте: yes, no, noise и background. Для этого выполните следующие шаги:

• Скачайте набор ключевых слов.
• Распакуйте файл в удобное место.

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

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

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

Поэтому подойдёт любое устройство, которое может создавать аудиоданные с такими базовыми параметрами (16 кГц/16 бит). В качестве устройства можно использовать XIAO ESP32S3 Sense, компьютер или даже смартфон.

Онлайн-запись аудиоданных с Edge Impulse и смартфона

В лабораторной работе «Классификация движения и обнаружение аномалий» мы подключали устройство напрямую к Edge Impulse Studio для сбора данных (с частотой дискретизации 50–100 Гц). Для такой низкой частоты можно было использовать функцию CLI Data Forwarder, однако, по словам Jan Jongboom, CTO Edge Impulse, аудио (16 кГц) передаётся слишком быстро для Data Forwarder. Поэтому, получив цифровые данные с микрофона, мы можем превратить их в файл WAV и отправить в Studio через Data Uploader (так же, как мы поступим с набором Пита).

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

Офлайн-запись аудиоданных с XIAO ESP32S3 Sense

Встроенный микрофон — MSM261D3526H1CPM, MEMS-микрофон с PDM-выходом и несколькими режимами работы. Внутри он подключён к ESP32S3 через шину I2S: выводы IO42 (тактовый сигнал) и IO41 (данные).

Что такое I2S?

I2S (Inter-IC Sound) — стандартный протокол для передачи цифрового аудио от одного устройства к другому. Его первоначально разработала Philips Semiconductor (ныне NXP Semiconductors). Он широко используется в аудиоустройствах, например в цифровых сигнальных процессорах, цифровых аудиопроцессорах и, всё чаще, в микроконтроллерах с поддержкой цифрового аудио (как в нашем случае).

Протокол I2S состоит как минимум из трёх линий:

1. Линия битового (или последовательного) тактового сигнала (BCLK или CLK): переключается, чтобы обозначить начало нового бита данных (вывод IO42).

2. Линия выбора слова (WS): переключается, чтобы обозначить начало нового слова (левого или правого канала). Частота сигнала выбора слова (WS) задаёт частоту дискретизации. В нашем случае вывод L/R на микрофоне подключён к земле, поэтому используется только левый канал (моно).

3. Линия данных (SD): по ней передаются аудиоданные (вывод IO41).

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

Начнём с того, как записывать сырые данные с микрофона. Перейдите в проект на GitHub и скачайте скетч XIAOEsp2s3_Mic_Test:

⚠️ Внимание

• На XIAO ESP32S3 ОБЯЗАТЕЛЬНО должна быть включена PSRAM. Проверить это можно в верхнем меню Arduino IDE: Tools → PSRAM:OPI PSRAM;
• Пакет поддержки плат (esp32 by Espressif Systems) должен быть версии 2.0.17. Пожалуйста, не обновляйте его.

/*
  Простой тест микрофона XIAO ESP32S3
*/

#include <I2S.h>

void setup() {
  Serial.begin(115200);
  while (!Serial) {
  }

  // Запуск I2S с частотой 16 кГц и 16 битами на отсчёт
  I2S.setAllPins(-1, 42, 41, -1, -1);
  if (!I2S.begin(PDM_MONO_MODE, 16000, 16)) {
    Serial.println("Failed to initialize I2S!");
    while (1); // ничего не делать
  }
}

void loop() {
  // Считываем отсчёт
  int sample = I2S.read();

  if (sample && sample != -1 && sample != 1) {
    Serial.println(sample);
  }
}

Этот код — простой тест микрофона XIAO ESP32S3 с интерфейсом I2S (Inter-IC Sound). Он настраивает I2S на захват аудио с частотой дискретизации 16 кГц и 16 битами на отсчёт, затем непрерывно читает отсчёты с микрофона и выводит их в последовательный порт.

Разберём основные части кода:

• Подключение библиотеки I2S: она предоставляет функции для настройки и использования интерфейса I2S, который является стандартом для подключения цифровых аудиоустройств.
• I2S.setAllPins(-1, 42, 41, -1, -1): настраивает выводы I2S. Параметры — (-1, 42, 41, -1, -1): второй параметр (42) — вывод тактового сигнала I2S (CLK), третий (41) — вывод данных I2S (DATA). Остальные параметры равны -1, то есть эти выводы не используются.
• I2S.begin(PDM_MONO_MODE, 16000, 16): инициализирует I2S в режиме моно PDM (Pulse Density Modulation) с частотой дискретизации 16 кГц и 16 битами на отсчёт. Если инициализация не удалась, выводится сообщение об ошибке и программа останавливается.
• int sample = I2S.read(): считывает отсчёт аудио из интерфейса I2S.

Если отсчёт корректен, он выводится в Serial Monitor и Plotter.

Ниже показан тест: «шёпот» двумя разными тонами.

Сохранение записанных звуковых образцов

Для записи аудиофайлов .wav на встроенный считыватель SD-карт нужно сначала включить PSRAM на XIAO.

В ESP32-S3 на чипе микроконтроллера всего несколько сотен килобайт внутренней оперативной памяти. Этого может не хватить для некоторых задач, поэтому ESP32-S3 может использовать до 16 МБ внешней PSRAM (псевдостатического ОЗУ), подключённой параллельно к флеш-чипу SPI. Внешняя память включена в адресное пространство процессора и при определённых ограничениях может использоваться так же, как внутренняя оперативная память данных.

Для начала вставьте SD-карту в XIAO, как показано на фото ниже (SD-карта должна быть отформатирована в FAT32).

Включите функцию PSRAM микросхемы ESP-32 (Arduino IDE): Tools > PSRAM: "OPI PSRAM" > OPI PSRAM.

• Скачайте скетч Wav_Record_dataset из репозитория проекта на GitHub.

Этот код записывает аудио через интерфейс I2S платы Seeed XIAO ESP32S3 Sense, сохраняет запись в виде файла .wav на SD-карту и позволяет управлять процессом записи командами, которые отправляются через Serial Monitor. Имя аудиофайла можно задать (оно должно совпадать с метками классов для обучения), и можно делать несколько записей, каждая из которых сохраняется в новый файл. Код также включает функцию увеличения громкости записей.

Разберём самые важные части кода:

#include <I2S.h>
#include "FS.h"
#include "SD.h"
#include "SPI.h"

Это необходимые библиотеки для программы. I2S.h позволяет вводить аудио, FS.h предоставляет возможности работы с файловой системой, SD.h позволяет программе работать с SD-картой, а SPI.h отвечает за связь SPI с SD-картой.

#define RECORD_TIME   10
#define SAMPLE_RATE 16000U
#define SAMPLE_BITS 16
#define WAV_HEADER_SIZE 44
#define VOLUME_GAIN 2

Здесь заданы различные константы программы.

• RECORD_TIME задаёт длительность записи аудио в секундах.
• SAMPLE_RATE и SAMPLE_BITS задают качество записи.
• WAV_HEADER_SIZE задаёт размер заголовка файла .wav.
• VOLUME_GAIN используется для увеличения громкости записи.

int fileNumber = 1;
String baseFileName;
bool isRecording = false;

Эти переменные хранят номер текущего файла (для создания уникальных имён файлов), базовое имя файла и признак того, идёт ли сейчас запись.

void setup() {
  Serial.begin(115200);
  while (!Serial);

  I2S.setAllPins(-1, 42, 41, -1, -1);
  if (!I2S.begin(PDM_MONO_MODE, SAMPLE_RATE, SAMPLE_BITS)) {
    Serial.println("Failed to initialize I2S!");
    while (1);
  }

  if(!SD.begin(21)){
    Serial.println("Failed to mount SD Card!");
    while (1);
  }
  Serial.printf("Enter with the label name\n");
}

Функция setup инициализирует последовательный порт, интерфейс I2S для аудиовхода и интерфейс SD-карты. Если I2S не инициализировался или SD-карта не смонтировалась, выводится сообщение об ошибке и выполнение останавливается.

void loop() {
  if (Serial.available() > 0) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    if (command == "rec") {
      isRecording = true;
    } else {
      baseFileName = command;
      fileNumber = 1; // сбрасываем номер файла при каждом
                        // задании нового базового имени
      Serial.printf("Send rec for starting recording label \n");
    }
  }
  if (isRecording && baseFileName != "") {
    String fileName = "/" + baseFileName + "."
                      + String(fileNumber) + ".wav";
    fileNumber++;
    record_wav(fileName);
    delay(1000); // задержка, чтобы не записать несколько файлов
                    // одновременно
    isRecording = false;
  }
}

В основном цикле программа ждёт команду из Serial Monitor. Если команда — rec, программа начинает запись. В противном случае команда считается базовым именем для файлов .wav. Если сейчас идёт запись и задано базовое имя, программа записывает аудио и сохраняет его в файл .wav. Имена файлов формируются добавлением номера файла к базовому имени.

void record_wav(String fileName)
{
  ...

  File file = SD.open(fileName.c_str(), FILE_WRITE);
  ...
  rec_buffer = (uint8_t *)ps_malloc(record_size);
  ...

  esp_i2s::i2s_read(esp_i2s::I2S_NUM_0,
                    rec_buffer,
                    record_size,
                    &sample_size,
                    portMAX_DELAY);
  ...
}

Эта функция записывает аудио и сохраняет его в файл .wav с заданным именем. Сначала инициализируются переменные sample_size и record_size. Значение record_size вычисляется по частоте дискретизации, разрядности и желаемой длительности записи. Рассмотрим важные части:

File file = SD.open(fileName.c_str(), FILE_WRITE);
// Записываем заголовок в файл WAV
uint8_t wav_header[WAV_HEADER_SIZE];
generate_wav_header(wav_header, record_size, SAMPLE_RATE);
file.write(wav_header, WAV_HEADER_SIZE);

Этот фрагмент открывает файл на SD-карте для записи, формирует заголовок .wav с помощью функции generate_wav_header и записывает его в файл.

// Выделение памяти в PSRAM для записи
rec_buffer = (uint8_t *)ps_malloc(record_size);
if (rec_buffer == NULL) {
  Serial.printf("malloc failed!\n");
  while(1) ;
}
Serial.printf("Buffer: %d bytes\n", ESP.getPsramSize()
               - ESP.getFreePsram());

Функция ps_malloc выделяет память в PSRAM для записи. Если выделение не удалось (rec_buffer равен NULL), выводится сообщение об ошибке и выполнение останавливается.

// Запуск записи
esp_i2s::i2s_read(esp_i2s::I2S_NUM_0,
         rec_buffer,
         record_size,
         &sample_size,
         portMAX_DELAY);
if (sample_size == 0) {
  Serial.printf("Record Failed!\n");
} else {
    Serial.printf("Record %d bytes\n", sample_size);
  }

Функция i2s_read считывает аудиоданные с микрофона в rec_buffer. Если данные не прочитаны (sample_size равен 0), выводится сообщение об ошибке.

// Увеличиваем громкость
for (uint32_t i = 0; i < sample_size; i += SAMPLE_BITS/8) {
  (*(uint16_t *)(rec_buffer+i)) <<= VOLUME_GAIN;
}

Этот фрагмент увеличивает громкость записи, сдвигая значения отсчётов на VOLUME_GAIN.

// Записываем данные в файл WAV
Serial.printf("Writing to the file ...\n");
if (file.write(rec_buffer, record_size) != record_size)
  Serial.printf("Write file Failed!\n");

free(rec_buffer);
file.close();
Serial.printf("Recording complete: \n");
Serial.printf("Send rec for a new sample or enter "
              "a new label\n\n");

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

void generate_wav_header(uint8_t *wav_header,
             uint32_t wav_size,
             uint32_t sample_rate)
{
  ...
  memcpy(wav_header, set_wav_header, sizeof(set_wav_header));
}

Функция generate_wav_header формирует заголовок файла .wav на основе параметров (wav_size и sample_rate). Она создаёт массив байтов по формату .wav: поля размера файла, аудиоформата, количества каналов, частоты дискретизации, битовой скорости, выравнивания блоков, разрядности и размера данных. Готовый заголовок копируется в массив wav_header, переданный в функцию.

Теперь загрузите код на XIAO и запишите образцы ключевых слов (yes и no). Также можно записать шум и другие слова.

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

Отправьте метку (например, yes). Программа будет ждать следующую команду: rec.

Программа будет записывать новые образцы каждый раз, когда получает команду rec. Файлы сохраняются как yes.1.wav, yes.2.wav, yes.3.wav и так далее, пока не будет отправлена новая метка (например, no). В этом случае для каждого нового образца нужно отправлять команду rec; файлы будут сохраняться как no.1.wav, no.2.wav, no.3.wav и так далее.

В итоге на SD-карте появятся сохранённые файлы.

Файлы готовы к загрузке в Edge Impulse Studio.

Приложения для офлайн-записи аудиоданных

Аудиоданные можно записывать разными способами. Самый простой — использовать смартфон или ПК как подключённое устройство в Edge Impulse Studio.

ПК или смартфон должны записывать аудио с частотой дискретизации 16 кГц и разрядностью 16 бит.

Другой вариант — специализированные приложения. Хорошее приложение для этого — Voice Recorder Pro (iOS). Записи нужно сохранять как файлы .wav и отправлять на компьютер.

Обучение модели в Edge Impulse Studio

Загрузка данных

Когда сырой набор данных определён и собран (набор Пита и записанные ключевые слова), создадим новый проект в Edge Impulse Studio:

После создания проекта выберите инструмент Upload Existing Data в разделе Data Acquisition. Выберите файлы для загрузки:

Загрузите их в Studio (можно автоматически разделить данные на обучающую и тестовую выборки). Повторите для всех классов и всех сырых данных.

Образцы появятся в разделе Data acquisition.

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

Нажмите «три точки» после названия образца и выберите Split sample.

Внутри инструмента разбейте данные на записи по 1 секунде. При необходимости добавьте или удалите сегменты:

Эту процедуру нужно повторить для всех образцов.

Примечание: для более длинных аудиофайлов (минуты) сначала разбейте их на сегменты по 10 секунд, а затем снова используйте инструмент, чтобы получить окончательные отрезки по 1 секунде.

Если при загрузке данные не разделялись автоматически на обучающую и тестовую выборки, это можно сделать вручную (через меню «три точки», перемещая образцы по одному) или с помощью Perform Train / Test Split на вкладке Dashboard в разделе Danger Zone.

При желании все наборы данных можно проверить на вкладке Data Explorer.

Создание Impulse (предобработка и определение модели)

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

Сначала мы возьмём точки данных с окном в 1 секунду, применим аугментацию и будем сдвигать окно каждые 500 мс. Обратите внимание, что включён параметр zero-pad data (дополнение нулями). Он важен: образцы короче 1 секунды дополняются нулями (в некоторых случаях я уменьшал окно 1000 мс в инструменте разбиения, чтобы избежать шумов и выбросов).

Каждый образец аудио длиной 1 секунда предобрабатывается и преобразуется в изображение (например, $13\times 49\times 1$). Мы будем использовать MFCC — метод, который извлекает признаки из аудиосигналов с помощью мел-частотных кепстральных коэффициентов, хорошо подходящих для человеческого голоса.

Далее мы выбираем Keras для классификации и строим модель с нуля, используя классификацию изображений с помощью свёрточной нейронной сети (CNN).

Предобработка (MFCC)

Следующий шаг — создать изображения для обучения на следующем этапе:

Можно оставить значения параметров по умолчанию или воспользоваться опцией DSP Autotune parameters, что и сделаем.

Предобработка почти не расходует памяти (всего 16 КБ), однако расчётное время обработки довольно велико: 675 мс для Espressif ESP-EYE (ближайший доступный эталон) при тактовой частоте 240 МГц (как у нашего устройства), но с более слабым процессором (Xtensa LX6 вместо LX7 у ESP32S3). Реальное время инференса должно быть меньше.

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

Пока оставим параметры, заданные инструментом автонастройки. Сохраним параметры и сгенерируем признаки.

Если хотите подробнее изучить преобразование временных последовательных данных в изображения с помощью FFT, спектрограммы и т. п., можете поэкспериментировать с этим блокнотом Colab: Audio Raw Data Analysis.

Проектирование модели и обучение

Мы будем использовать свёрточную нейронную сеть (CNN). Базовая архитектура состоит из двух блоков Conv1D + MaxPooling (с 8 и 16 нейронами соответственно) и Dropout 0,25. На последнем слое, после Flatten, четыре нейрона — по одному на каждый класс:

Гиперпараметры: скорость обучения (Learning Rate) 0,005, модель обучается за 100 эпох. Также добавим аугментацию данных, в том числе добавление шума. Результат выглядит хорошо:

Если хотите понять, что происходит «под капотом», можно скачать набор данных и запустить блокнот Jupyter, поэкспериментировать с кодом. Например, можно проанализировать точность по каждой эпохе:

Этот блокнот Colab поможет узнать, как двигаться дальше: KWS Classifier Project — Looking «Under the hood».

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

Тестирование модели на данных, отложенных до обучения (тестовых данных), дало точность около 87 %.

Если посмотреть F1-меру, для YES получилось 0,95 — отличный результат, поскольку именно это слово мы будем использовать как «триггер» для постобработки (включения встроенного светодиода). Даже для NO получилось 0,90. Худший результат — у unknown, и это нормально.

Можно переходить к проекту, но перед развёртыванием на устройстве полезно выполнить классификацию в реальном времени с помощью смартфона. Перейдите в раздел Live Classification и нажмите Connect a Development board:

Наведите телефон на QR-код и выберите ссылку.

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

Развёртывание и инференс

Studio упакует все нужные библиотеки, функции предобработки и обученные модели и загрузит их на компьютер. Выберите опцию Arduino Library, затем внизу выберите Quantized (Int8) и нажмите Build.

Теперь пора провести настоящий тест. Мы будем делать инференс, полностью отключившись от Studio. Изменим один из примеров кода для ESP32, созданных при развёртывании Arduino Library.

В Arduino IDE откройте вкладку File/Examples, найдите свой проект и выберите esp32/esp32_microphone:

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

Начнём с замены библиотек для работы с шиной I2S:

На:

#include <I2S.h>
#define SAMPLE_RATE 16000U
#define SAMPLE_BITS 16

Инициализируйте микрофон I2S в функции setup(), добавив строки:

void setup()
{
...
    I2S.setAllPins(-1, 42, 41, -1, -1);
    if (!I2S.begin(PDM_MONO_MODE, SAMPLE_RATE, SAMPLE_BITS)) {
      Serial.println("Failed to initialize I2S!");
    while (1) ;
...
}

В функции static void capture_samples(void* arg) замените строку 153, которая читает данные с микрофона I2S:

На:

/* Чтение данных сразу из i2s */
esp_i2s::i2s_read(esp_i2s::I2S_NUM_0,
                 (void*)sampleBuffer,
                 i2s_bytes_to_read,
                 &bytes_read, 100);

В функции static bool microphone_inference_start(uint32_t n_samples) закомментируйте или удалите строки 198–200, где вызывается функция инициализации микрофона. Она больше не нужна, поскольку микрофон I2S уже инициализирован в setup().

Наконец, в функции static void microphone_inference_end(void) замените строку 243:

На:

static void microphone_inference_end(void)
{
    free(sampleBuffer);
    ei_free(inference.buffer);
}

Полный код есть в репозитории проекта на GitHub. Загрузите скетч на плату и проверьте реальный инференс:

⚠️ Внимание

• На XIAO ESP32S3 ОБЯЗАТЕЛЬНО должна быть включена PSRAM. Проверить это можно в верхнем меню Arduino IDE: Tools → PSRAM:OPI PSRAM;
• Пакет поддержки плат (esp32 by Espressif Systems) должен быть версии 2.0.17. Пожалуйста, не обновляйте его.

Постобработка

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

Рассмотрим два подхода к постобработке: использование встроенного светодиода XIAO и OLED-дисплея в XIAOML Kit.

Светодиод

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

Нужно инициализировать светодиод:

#define LED_BUILT_IN 21
...
void setup()
{
...
  pinMode(LED_BUILT_IN, OUTPUT); // Настраиваем вывод на выход
  digitalWrite(LED_BUILT_IN, HIGH); // Выключить
...
}

Затем замените фрагмент // print the predictions в предыдущем коде (в функции loop()):

int pred_index = 0;     // Инициализация pred_index
float pred_value = 0;   // Инициализация pred_value

// вывод предсказаний
ei_printf("Predictions ");
ei_printf("(DSP: %d ms., Classification: %d ms., Anomaly: %d ms.)",
     result.timing.dsp, result.timing.classification,
     result.timing.anomaly);
ei_printf(": \n");
for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
      ei_printf("    %s: ", result.classification[ix].label);
      ei_printf_float(result.classification[ix].value);
      ei_printf("\n");

      if (result.classification[ix].value > pred_value){
         pred_index = ix;
         pred_value = result.classification[ix].value;
      }
}

// показываем результат инференса светодиодом
if (pred_index == 3){
    digitalWrite(LED_BUILT_IN, LOW); // Включить
}
else{
   digitalWrite(LED_BUILT_IN, HIGH); // Выключить
}

Полный код есть в репозитории проекта на GitHub. Загрузите скетч на плату и проверьте реальный инференс:

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

OLED-дисплей

Маленький 0,42-дюймовый OLED-дисплей XIAOML Kit ($72\times 40$ пикселей) — важный компонент постобработки: он превращает сырые результаты инференса в немедленную, понятную человеку обратную связь, показывая названия классов и уровни уверенности прямо на устройстве. Это исключает необходимость во внешних мониторах и позволяет создавать по-настоящему автономные периферийные ИИ-системы в промышленности, сельском хозяйстве или розничной торговле, где мгновенное визуальное подтверждение предсказаний ИИ особенно важно.

Теперь изменим скетч так, чтобы он автоматически адаптировался к модели, обученной в Edge Impulse: он будет читать названия классов и их количество прямо из модели. Скачайте код с GitHub: xiaoml-kit_kws_oled.

Запустим код и посмотрим результат:

Итоги

Эта лабораторная работа продемонстрировала полный цикл разработки системы распознавания ключевых слов на XIAOML Kit и показала, как современные платформы TinyML делают сложный аудио-ИИ доступным на устройствах с ограниченными ресурсами. В ходе практической реализации мы соединили теоретические концепции машинного обучения с практическим развёртыванием встраиваемого ИИ.

Технические достижения. Проект реализует полный конвейер обработки аудио: от захвата сырого звука до инференса в реальном времени. Используя встроенный цифровой микрофон XIAO ESP32S3, мы записали аудио профессионального качества (16 кГц/16 бит) и обработали его с помощью мел-частотных кепстральных коэффициентов (MFCC) для извлечения признаков. Развёрнутая CNN-модель достигла высокой точности в различении целевых ключевых слов («YES», «NO») и фоновых условий («NOISE», «UNKNOWN»), а время инференса подходит для приложений реального времени.

Интеграция с платформой. Edge Impulse Studio оказалась незаменимой комплексной MLOps-платформой для встраиваемых систем: она охватывает всё — от сбора и разметки данных до обучения, оптимизации и развёртывания моделей. Бесшовная интеграция облачного обучения и развёртывания на периферии характерна для современных рабочих процессов TinyML, а Arduino IDE обеспечила гибкость, нужную для собственной постобработки.

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

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

Методология разработки. Мы рассмотрели несколько путей разработки: от стратегий сбора данных (офлайн-запись на SD-карту или онлайн-потоковая передача) до вариантов развёртывания (автоматическая генерация библиотеки в Edge Impulse или собственная реализация на Arduino). Такая гибкость важна для адаптации к разным требованиям и ограничениям проектов.

Дальнейшее развитие. Основа, заложенная здесь, открывает путь к более продвинутым приложениям аудио-ИИ. Распознавание нескольких ключевых слов, идентификация говорящего, определение эмоций по голосу и классификация звуков окружающей среды опираются на те же базовые методы. Возможности интеграции, продемонстрированные с OLED-дисплеем и управлением GPIO, показывают, как KWS может служить интеллектуальным интерфейсом для более широких IoT-систем.

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

• Безопасность: обнаружение битого стекла, мониторинг вторжений, распознавание выстрелов;
• Промышленный IoT: мониторинг состояния оборудования, обнаружение аномалий в производственном оборудовании;
• Здравоохранение: мониторинг нарушений сна, оценка состояния дыхательной системы, системы ухода за пожилыми людьми;
• Экологический мониторинг: отслеживание дикой природы, анализ городского шума, акустическое управление «умными» зданиями;
• Интеграция с умным домом: голосовое управление в нескольких комнатах, контроль состояния бытовой техники по звуковым признакам.

Ключевые выводы. XIAOML Kit доказывает, что разработка ИИ профессионального уровня достижима с помощью доступных инструментов и при скромном бюджете. Сочетание мощного оборудования (ESP32S3 с PSRAM и встроенными датчиками), зрелых платформ разработки (Edge Impulse Studio) и полноценных программных библиотек создаёт среду, в которой сложные концепции ИИ превращаются в осязаемые работающие системы.

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

Ресурсы

• Код XIAO ESP32S3

• Код XIAOML Kit

• Подмножество набора Google Speech Commands

• Блокнот Colab: KWS MFCC Analysis

• Блокнот Colab: KWS CNN training

• Код постобработки для XIAO ESP32S3

• Проект Edge Impulse

Классификация движения и обнаружение аномалий

Промпт DALL·E: мультяшная иллюстрация в стиле 1950-х в винтажной аудиолаборатории. Учёные в классических белых халатах внимательно анализируют аудиоданные на больших досках. На досках — графики БПФ (быстрого преобразования Фурье) и кривые во временной области. Вокруг разбросано старинное аудиооборудование, но графики данных ясные и подробные, что подчёркивает внимание к анализу звука.

Обзор

Транспорт — основа мировой торговли. Миллионы контейнеров ежедневно перевозятся морем, автомобилями и поездами в разные уголки мира. Безопасная и эффективная перевозка контейнеров — огромная задача, которая требует современных технологий, и TinyML, без сомнения, — одно из ключевых решений.

В этой практической работе мы будем решать реальные задачи транспортной логистики. Мы разработаем систему классификации движения и обнаружения аномалий на основе XIAOML Kit, Arduino IDE и Edge Impulse Studio. Проект поможет понять, какие силы и движения испытывает контейнер на разных этапах перевозки: при наземной и морской транспортировке, при вертикальном перемещении вилочным погрузчиком и при хранении на складе.

Цели обучения

• настройка XIAOML Kit;
• сбор и предобработка данных;
• создание модели классификации движения;
• реализация обнаружения аномалий;
• тестирование и анализ в реальных условиях.

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

Установка IMU

В комплект XIAOML Kit на плате расширения уже встроен 6-осевой датчик IMU LSM6DS3TR-C, поэтому внешние датчики подключать не нужно. Такое встроенное решение даёт чистую и надёжную платформу для приложений машинного обучения на основе движения.

LSM6DS3TR-C объединяет в одном корпусе 3-осевой акселерометр и 3-осевой гироскоп. Он подключён по шине I2C к XIAO ESP32S3 по адресу 0x6A и обеспечивает:

• диапазоны акселерометра: ±2/±4/±8/±16 g (по умолчанию используем ±2 g);
• диапазоны гироскопа: ±125/±250/±500/±1000/±2000 dps (по умолчанию используем ±250 dps);
• разрешение: 16-битный АЦП;
• интерфейс связи: I2C, адрес 0x6A;
• энергопотребление: сверхнизкое.

Система координат. Датчик работает в правосторонней системе координат. Если смотреть на плату расширения снизу (там, где виден датчик IMU с меткой-точкой):

• ось X направлена вправо;
• ось Y направлена вперёд (от вас);
• ось Z направлена вверх (из платы).

Настройка аппаратной части

Поскольку XIAOML Kit поставляется собранным с платой расширения, дополнительных аппаратных соединений не требуется. Датчик LSM6DS3TR-C уже правильно подключён по I2C.

Что уже подключено:

• IMU LSM6DS3TR-C → I2C (SDA/SCL) → XIAO ESP32S3;
• адрес I2C: 0x6A;
• питание: 3,3 В от XIAO ESP32S3.

Необходимая библиотека. Библиотека должна была быть установлена во время настройки. Если это не так, установите библиотеку Seeed Arduino LSM6DS3, выполнив такие шаги:

1. Откройте Library Manager в Arduino IDE.
2. Найдите «LSM6DS3».
3. Установите «Seeed Arduino LSM6DS3» от Seeed Studio.
4. Важно: НЕ устанавливайте «Arduino_LSM6DS3 by Arduino» — она предназначена для других плат!

Проверка датчика IMU

Начнём с простого теста, чтобы убедиться, что IMU работает правильно. Загрузите этот код для проверки датчика:

#include <LSM6DS3.h>
#include <Wire.h>

// Создаём объект IMU через интерфейс I2C
LSM6DS3 myIMU(I2C_MODE, 0x6A);

float accelX, accelY, accelZ;
float gyroX, gyroY, gyroZ;

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);

  Serial.println("Тест IMU XIAOML Kit");
  Serial.println("6-осевой IMU LSM6DS3TR-C");
  Serial.println("====================");

  // Инициализируем IMU
  if (myIMU.begin() != 0) {
      Serial.println("ОШИБКА: не удалось инициализировать IMU!");
      while(1) delay(1000);
  } else {
      Serial.println("✓ IMU успешно инициализирован");
      Serial.println("Формат данных: AccelX,AccelY,AccelZ,"
                    "GyroX,GyroY,GyroZ");
      Serial.println("Единицы: g (ускорение свободного падения), градусы/с");
      Serial.println();
  }
}

void loop() {
  // Читаем данные акселерометра (в g)
  accelX = myIMU.readFloatAccelX();
  accelY = myIMU.readFloatAccelY();
  accelZ = myIMU.readFloatAccelZ();

  // Читаем данные гироскопа (в градусах в секунду)
  gyroX = myIMU.readFloatGyroX();
  gyroY = myIMU.readFloatGyroY();
  gyroZ = myIMU.readFloatGyroZ();

  // Выводим в удобном для чтения формате
  Serial.print("Акселерометр (g): X="); Serial.print(accelX, 3);
  Serial.print(" Y="); Serial.print(accelY, 3);
  Serial.print(" Z="); Serial.print(accelZ, 3);
  Serial.print(" | Гироскоп (°/с): X="); Serial.print(gyroX, 2);
  Serial.print(" Y="); Serial.print(gyroY, 2);
  Serial.print(" Z="); Serial.println(gyroZ, 2);

  delay(100); // частота обновления 10 Гц
}

Когда комплект лежит ровно на столе, вы должны увидеть:

• ускорение по оси Z около +1,0 g (гравитация);
• ускорение по осям X и Y близко к 0,0 g;
• все значения гироскопа близки к 0,0 °/с.

Пошевелите комплект, чтобы увидеть, как меняются значения.

Проект классификации движения TinyML

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

С помощью акселерометра XIAOML Kit мы будем записывать данные о движении, вручную имитируя условия:

• морская перевозка (паллеты на лодках) — движение по всем осям с волнообразными колебаниями;
• наземная перевозка (паллеты на грузовиках или поездах) — преимущественно горизонтальное движение;
• подъём (паллеты, которые перемещает вилочный погрузчик) — преимущественно вертикальное движение;
• простой (паллеты на складе) — минимальное движение.

По изображению выше мы определим для нашей симуляции: преимущественно горизонтальные движения (по осям $x$ или $y$) соответствуют классу «Наземная перевозка», вертикальные движения (ось $z$) — классу «Подъём», отсутствие активности — классу «Простой», а движение по всем трём осям — классу «Морская перевозка».

Сбор данных

Для сбора данных есть несколько вариантов. В реальном сценарии устройство можно подключить непосредственно к контейнеру, а собранные данные сохранять в файл (например, CSV) на SD-карте. Данные можно также передавать удалённо на ближайший накопитель, например на телефон, по Wi-Fi или Bluetooth (как в проекте Sensor DataLogger). Когда набор данных собран и сохранён как файл .CSV, его можно загрузить в Studio с помощью инструмента CSV Wizard.

В этом видео вы узнаете о других способах отправки данных в Edge Impulse Studio.

Подготовка кода для сбора данных

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

Для сбора данных сначала подключите комплект к Edge Impulse Studio, которая будет также использоваться для предобработки данных, обучения модели, тестирования и развёртывания.

Следуйте инструкциям, чтобы установить Node.js и Edge Impulse CLI на ваш компьютер.

Поскольку XIAOML Kit не является полностью поддерживаемой отладочной платой Edge Impulse, для захвата данных с датчика и отправки их в Studio используем CLI Data Forwarder, как показано на схеме:

Изменим тестовый код так, чтобы он выводил данные в формате, подходящем для Edge Impulse:

#include <LSM6DS3.h>
#include <Wire.h>

#define FREQUENCY_HZ        50
#define INTERVAL_MS         (1000 / (FREQUENCY_HZ + 1))

LSM6DS3 myIMU(I2C_MODE, 0x6A);
static unsigned long last_interval_ms = 0;

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);

  Serial.println("XIAOML Kit — сбор данных о движении");
  Serial.println("Датчик IMU LSM6DS3TR-C");

  // Инициализируем IMU
  if (myIMU.begin() != 0) {
      Serial.println("ОШИБКА: не удалось инициализировать IMU!");
      while(1) delay(1000);
  }
  delay(2000);
  Serial.println("Начало сбора данных через 3 секунды...");
  delay(3000);
}

void loop() {
  if (millis() > last_interval_ms + INTERVAL_MS) {
      last_interval_ms = millis();

      // Читаем данные акселерометра
      float ax = myIMU.readFloatAccelX();
      float ay = myIMU.readFloatAccelY();
      float az = myIMU.readFloatAccelZ();

      // Переводим в м/с² (умножаем на 9,81)
      float ax_ms2 = ax * 9.81;
      float ay_ms2 = ay * 9.81;
      float az_ms2 = az * 9.81;

      // Выводим в формате Edge Impulse
      Serial.print(ax_ms2);
      Serial.print("\t");
      Serial.print(ay_ms2);
      Serial.print("\t");
      Serial.println(az_ms2);
  }
}

Загрузите код в Arduino IDE. В Serial Monitor должны появиться значения акселерометра (переведённые в м/с²):

Оставьте код запущенным, но выключите Serial Monitor. Данные с комплекта будут отправлены в Edge Impulse Studio по последовательному соединению.

Подключение к Edge Impulse для сбора данных

Создайте проект Edge Impulse

• Перейдите в Edge Impulse Studio и создайте новый проект.
• Выберите понятное название (не длиннее 63 символов для совместимости с библиотеками Arduino).

Настройте CLI Data Forwarder

• Установите Edge Impulse CLI на компьютер.
• Убедитесь, что XIAOML Kit подключён к компьютеру, код запущен, а Serial Monitor выключен, иначе может возникнуть ошибка.
• В терминале компьютера выполните: edge-impulse-data-forwarder --clean.
• Введите учётные данные Edge Impulse.
• Выберите проект и настройте параметры устройства.

• Откройте проект в Edge Impulse Studio. В разделе Device можно проверить, правильно ли подключён комплект (точка должна быть зелёной).

Сбор данных в Studio

Как обсуждалось ранее, нужно собрать данные для всех четырёх классов перевозки. Представьте, что у вас есть контейнер со встроенным акселерометром (в нашем случае это XIAOML Kit). Теперь представьте, что контейнер стоит на корабле в бушующем океане:

Или в грузовике, который едет по дороге, или его перемещает вилочный погрузчик и т. д.

Имитация движения

Класс «Морская перевозка»:

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

Класс «Наземная перевозка»:

• двигайте комплект горизонтально по прямым линиям (слева направо и обратно);
• имитируйте вибрации грузовика или поезда небольшими горизонтальными встряхиваниями;
• иногда делайте плавные толчки и повороты.

Класс «Подъём»:

• двигайте комплект преимущественно по вертикали (вверх и вниз);
• имитируйте работу погрузчика: подъём, пауза, опускание;
• добавьте несколько коротких горизонтальных перемещений для позиционирования.

Класс «Простой»:

• поставьте комплект на устойчивую поверхность;
• минимальное движение или его отсутствие;
• фиксируйте окружающие вибрации и шум датчика.

Получение данных

В разделе Data Acquisition вы должны увидеть, что ваша плата [xiaoml-kit] подключена. Датчик доступен: [sensor with 3 axes (accX, accY, accZ)], с частотой дискретизации [50 Hz]. Studio предлагает длину образца [10000] мс (10 с). Осталось задать метку образца. Начнём, например, с [terrestrial].

Нажмите [Start Sample] и двигайте комплект горизонтально (слева направо), сохраняя одно направление. Через 10 секунд данные загрузятся в Studio.

Ниже показан один образец (сырые данные) длиной 10 секунд. Видно, что волнообразное движение происходит преимущественно по оси Y (слева направо). Остальные оси почти неподвижны: ось X колеблется около нуля, а ось Z — около 9,8 м/с² из-за гравитации.

Для каждого из четырёх классов соберите, например, около 2 минут данных (десять–двенадцать образцов по 10 секунд). С помощью значка 3 dots после каждого образца выберите два и перенесите их в Test set (тестовую выборку). Либо используйте автоматический инструмент Train/Test Split в разделе Danger Zone вкладки Dashboard. Ниже видны наборы данных:

Предобработка данных

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

видно 10 секунд данных акселерометра, записанных с частотой дискретизации (SR) 50 Гц. Окно длиной 2 секунды захватывает 300 точек данных (3 оси × 2 секунды × 50 отсчётов). Мы будем сдвигать это окно каждые 200 мс, создавая набор большего размера, где каждый экземпляр содержит 300 сырых признаков.

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

Предобработка данных — непростая задача для встраиваемого машинного обучения. Тем не менее Edge Impulse помогает справиться с ней благодаря шагу цифровой обработки сигналов (DSP), а точнее — спектральным признакам.

В Studio этот набор данных поступит на вход блока спектрального анализа (Spectral Analysis), который отлично подходит для анализа повторяющихся движений, например данных акселерометров. Блок выполняет DSP (цифровую обработку сигналов) и извлекает такие признаки, как «FFT» или «вейвлеты». В самом распространённом случае, при FFT, статистические признаки временной области для каждой оси/канала таковы:

• RMS;
• асимметрия (Skewness);
• эксцесс (Kurtosis).

А спектральные признаки частотной области для каждой оси/канала:

• спектральная мощность (Spectral Power);
• асимметрия (Skewness);
• эксцесс (Kurtosis).

Например, при длине FFT 32 точки на выходе блока спектрального анализа будет 21 признак на каждую ось (всего 63 признака).

Эти 63 признака станут входным тензором для нейросетевого классификатора и для модели обнаружения аномалий (K-Means).

Подробнее можно узнать из лабораторной работы Спектральные признаки DSP.

Проектирование модели

Наш классификатор будет полносвязной нейронной сетью (Dense Neural Network, DNN). У неё будет 63 нейрона на входном слое, два скрытых слоя с 20 и 10 нейронами и выходной слой с четырьмя нейронами (по одному на каждый класс), как показано здесь:

Проектирование Impulse

Impulse принимает сырые данные, с помощью обработки сигналов извлекает признаки, а затем использует блок обучения (Dense model), чтобы классифицировать новые данные.

Мы также используем вторую модель — K-means, которая применяется для обнаружения аномалий. Представим, что известные классы — это кластеры. Любой образец, который не попадает ни в один из этих кластеров, может оказаться выбросом, аномалией (например, контейнер, сорвавшийся с корабля в океан, или лежащий вверх дном на полу).

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

Итоговый дизайн Impulse:

Генерация признаков

На этом этапе проекта мы определили метод предобработки, и модель спроектирована. Теперь пора выполнить работу. Сначала преобразуем сырые данные (временной ряд) в табличные. Перейдите на вкладку Spectral Features и нажмите [Save Parameters]. Либо вместо значений по умолчанию нажмите кнопку [Autotune parameters]. В этом случае Studio сама подберёт гиперпараметры, например конструкцию фильтра и длину FFT, на основе сырых данных.

В верхнем меню выберите вкладку Generate features, отметьте опции Calculate feature importance и Normalize features и нажмите [Generate features]. Каждое двухсекундное окно данных (300 точек) будет преобразовано в одну табличную точку с 63 признаками.

Feature Explorer отобразит эти данные в 2D с помощью UMAP. Uniform Manifold Approximation and Projection (UMAP) — метод снижения размерности, который используется для визуализации, похоже на t-SNE, но также и для общего нелинейного снижения размерности.

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

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

Обучение

Наш классификатор — полносвязная нейронная сеть (DNN) со 63 нейронами на входном слое, двумя скрытыми слоями с 20 и 10 нейронами и выходным слоем из четырёх нейронов (по одному на класс), как показано здесь:

В качестве гиперпараметров используем скорость обучения (Learning Rate) 0,005 и 20 % данных для валидации, 30 эпох. После обучения точность составляет 100 %.

Для обнаружения аномалий выберем предложенные признаки, которые как раз и являются наиболее важными в извлечении признаков. Количество кластеров будет 32, как предлагает Studio. После обучения можно выбрать часть данных для проверки, например данные морской перевозки. Полученный показатель аномалий: min: -0.1642, max: 0.0738, avg: -0.0867.

Если менять данные, можно заметить, что малые или отрицательные значения показателя аномалий означают, что данные нормальные.

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

С помощью 20 % данных, оставшихся после этапа сбора, можно проверить, как модель поведёт себя на неизвестных данных. Ожидается 100 %, но результат оказался очень хорошим — 8 % ошибок.

Также используйте свой комплект (он всё ещё подключён к Studio) и проведите живую классификацию. Например, проверим движение «наземной перевозки»:

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

Развёртывание

Пришло время для волшебства! Studio упакует все нужные библиотеки, функции предобработки и обученные модели и загрузит их на ваш компьютер. Выберите вариант Arduino Library, затем внизу выберите Quantized (Int8) и нажмите [Build]. ZIP-файл будет создан и загружен на компьютер.

В Arduino IDE откройте вкладку Sketch, выберите пункт Add .ZIP Library и укажите ZIP-файл, который скачала Studio:

Инференс

Теперь пора провести настоящий тест. Мы будем делать инференс полностью независимо от Studio. Изменим один из примеров кода, который создала Studio при развёртывании библиотеки Arduino.

В Arduino IDE откройте вкладку File/Examples, найдите свой проект и в примерах выберите nano_ble_sense_accelerometer:

Конечно, это не ваша плата, но код можно адаптировать, внеся всего несколько изменений.

Например, в начале кода подключается библиотека для IMU Arduino Sense:

/* Подключение библиотек -------------------------------- */
#include <XIAOML_Kit_Motion_Class_-_AD_inferencing.h>
#include <Arduino_LSM9DS1.h>

Замените блок подключений на код для IMU:

#include <XIAOML_Kit_Motion_Class_-_AD_inferencing.h>
#include <LSM6DS3.h>
#include <Wire.h>

Измените константы:

// Настройка IMU
LSM6DS3 myIMU(I2C_MODE, 0x6A);

// Настройки инференса
#define CONVERT_G_TO_MS2    9.81f
#define MAX_ACCEPTED_RANGE  2.0f * CONVERT_G_TO_MS2

В функции setup инициализируйте IMU:

   // Инициализация IMU
    if (myIMU.begin() != 0) {
        Serial.println("ОШИБКА: не удалось инициализировать IMU!");
        return;
    }

В функции loop буферы buffer[ix], buffer[ix + 1] и buffer[ix + 2] получают данные трёхосного акселерометра. В исходном коде есть строка:

IMU.readAcceleration(buffer[ix], buffer[ix + 1], buffer[ix + 2]);

Замените её на такой блок кода:

// Читаем данные IMU
float x = myIMU.readFloatAccelX();
float y = myIMU.readFloatAccelY();
float z = myIMU.readFloatAccelZ();

Два блока кода нужно поменять местами. Сначала выполняется перевод в «метры на секунду в квадрате» (м/с²), затем проверка максимально допустимого диапазона (здесь он задан в м/с², а в примере для Arduino — в g):

  // Переводим в м/с²
  buffer[i + 0] = x * CONVERT_G_TO_MS2;
  buffer[i + 1] = y * CONVERT_G_TO_MS2;
  buffer[i + 2] = z * CONVERT_G_TO_MS2;

  // Ограничиваем диапазон
  for (int j = 0; j < 3; j++) {
      if (fabs(buffer[i + j]) > MAX_ACCEPTED_RANGE) {
          buffer[i + j] = copysign(MAX_ACCEPTED_RANGE, buffer[i + j]);
      }
  }

На этом изменения заканчиваются. Вывод инференса в Serial Monitor тоже можно настроить. Теперь загрузите полный код ниже на плату и переходите к инференсу.

// Классификация движения с датчиком LSM6DS3TR-C
#include <XIAOML_Kit_Motion_Class_-_AD_inferencing.h>
#include <LSM6DS3.h>
#include <Wire.h>

// Настройка IMU
LSM6DS3 myIMU(I2C_MODE, 0x6A);

// Настройки инференса
#define CONVERT_G_TO_MS2    9.81f
#define MAX_ACCEPTED_RANGE  2.0f * CONVERT_G_TO_MS2

static bool debug_nn = false;
static float buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE] = { 0 };
static float inference_buffer[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE];

void setup() {
    Serial.begin(115200);
    while (!Serial) delay(10);

    Serial.println("XIAOML Kit — классификация движения");
    Serial.println("Инференс с датчиком LSM6DS3TR-C");

    // Инициализация IMU
    if (myIMU.begin() != 0) {
        Serial.println("ОШИБКА: не удалось инициализировать IMU!");
        return;
    }

    Serial.println("✓ IMU инициализирован");

    if (EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME != 3) {
        Serial.println("ОШИБКА: EI_CLASSIFIER_RAW_SAMPLES_PER_FRAME "
                       "должен быть равен 3");
        return;
    }

    Serial.println("✓ Модель загружена");
    Serial.println("Запуск классификации движения...");
}

void loop() {
    ei_printf("\nЗапуск инференса через 2 секунды...\n");
    delay(2000);

    ei_printf("Сбор данных...\n");

    // Очищаем буфер
    for (size_t i = 0; i < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; i++) {
        buffer[i] = 0.0f;
    }

    // Собираем данные акселерометра
    for (int i = 0; i < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; i += 3) {
        uint64_t next_tick = micros() +
          (EI_CLASSIFIER_INTERVAL_MS * 1000);

        // Читаем данные IMU
        float x = myIMU.readFloatAccelX();
        float y = myIMU.readFloatAccelY();
        float z = myIMU.readFloatAccelZ();

        // Переводим в м/с²
        buffer[i + 0] = x * CONVERT_G_TO_MS2;
        buffer[i + 1] = y * CONVERT_G_TO_MS2;
        buffer[i + 2] = z * CONVERT_G_TO_MS2;

        // Ограничиваем диапазон
        for (int j = 0; j < 3; j++) {
            if (fabs(buffer[i + j]) > MAX_ACCEPTED_RANGE) {
                buffer[i + j] = copysign(MAX_ACCEPTED_RANGE,
                                         buffer[i + j]);
            }
        }

        delayMicroseconds(next_tick - micros());
    }

    // Копируем во входной буфер инференса
    for (int i = 0; i < EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE; i++) {
        inference_buffer[i] = buffer[i];
    }

    // Создаём сигнал из буфера
    signal_t signal;
    int err = numpy::signal_from_buffer(inference_buffer,
              EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
    if (err != 0) {
        ei_printf("ОШИБКА: не удалось создать сигнал из буфера (%d)\n",
                  err);
        return;
    }

    // Запускаем классификатор
    ei_impulse_result_t result = { 0 };
    err = run_classifier(&signal, &result, debug_nn);
    if (err != EI_IMPULSE_OK) {
        ei_printf("ОШИБКА: не удалось запустить классификатор (%d)\n", err);
        return;
    }

    // Выводим предсказания
    ei_printf("Предсказания (DSP: %d мс, классификация: %d мс, "
              "аномалии: %d мс):\n",
        result.timing.dsp, result.timing.classification, result.timing.anomaly);

    for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
        ei_printf("    %s: %.5f\n", result.classification[ix].label,
                  result.classification[ix].value);
    }

    // Выводим показатель аномалии
#if EI_CLASSIFIER_HAS_ANOMALY == 1
    ei_printf("Показатель аномалии: %.3f\n", result.anomaly);
#endif

    // Определяем предсказание
    float max_confidence = 0.0;
    String predicted_class = "unknown";

    for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++) {
        if (result.classification[ix].value > max_confidence) {
            max_confidence = result.classification[ix].value;
            predicted_class = String(result.classification[ix].label);
        }
    }

    // Выводим результат с порогом уверенности
    if (max_confidence > 0.6) {
        ei_printf("\n🎯 ПРЕДСКАЗАНИЕ: %s (уверенность %.1f%%)\n",
                 predicted_class.c_str(), max_confidence * 100);
    } else {
        ei_printf("\n❓ НЕОПРЕДЕЛЁННО: наибольшая уверенность у %s (%.1f%%)\n",
                 predicted_class.c_str(), max_confidence * 100);
    }

    // Проверяем аномалию
#if EI_CLASSIFIER_HAS_ANOMALY == 1
    if (result.anomaly > 0.5) {
        ei_printf("⚠️ ОБНАРУЖЕНА АНОМАЛИЯ! Показатель: %.3f\n", result.anomaly);
    }
#endif

    delay(1000);
}

void ei_printf(const char *format, ...) {
    static char print_buf[1024] = { 0 };
    va_list args;
    va_start(args, format);
    int r = vsnprintf(print_buf, sizeof(print_buf), format, args);
    va_end(args);
    if (r > 0) {
        Serial.write(print_buf);
    }
}

Полный код доступен на странице лабораторной работы на GitHub.

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

И, конечно, попробуйте «аномалию», например переверните XIAO вверх дном. Показатель аномалии превысит 0,5:

Постобработка

Теперь, когда мы убедились, что модель работает, предлагаем изменить код так, чтобы результат выводился полностью офлайн: без подключения к ПК и с питанием от аккумулятора, пауэрбанка или отдельного источника на 5 В.

Идея в том, что при обнаружении определённого движения на OLED-дисплее появляется соответствующее сообщение.

Изменённый код инференса с выводом на OLED-дисплей доступен на странице лабораторной работы на GitHub.

Итоги

В этой работе мы показали, как построить полную систему классификации движения на основе встроенного 6-осевого датчика IMU LSM6DS3TR-C из XIAOML Kit. Основные достижения:

Техническая реализация:

• использован встроенный 6-осевой IMU для регистрации движения;
• собраны размеченные обучающие данные для четырёх сценариев транспортировки;
• реализовано извлечение спектральных признаков для анализа временных рядов;
• развёрнут нейросетевой классификатор, оптимизированный для инференса на микроконтроллере;
• добавлено обнаружение аномалий для выявления необычных движений.

Конвейер машинного обучения:

• сбор данных напрямую со встраиваемых датчиков;
• инженерия признаков с помощью анализа в частотной области;
• обучение и оптимизация модели в Edge Impulse;
• инференс в реальном времени на аппаратуре с ограниченными ресурсами;
• контроль производительности и валидация.

Практические применения: изученные методы напрямую применяются в реальных сценариях, включая:

• отслеживание активов и мониторинг логистики;
• предиктивное обслуживание оборудования;
• распознавание человеческой активности;
• мониторинг транспортных средств и оборудования;
• сети IoT-датчиков для «умных городов».

Ключевые выводы:

• работа с системами координат IMU и слиянием данных датчиков;
• баланс между точностью модели и скоростью инференса на периферийных устройствах;
• построение надёжных конвейеров сбора и предобработки данных;
• развёртывание моделей машинного обучения во встраиваемых системах;
• объединение нескольких датчиков (IMU + дисплей) в полноценные решения.

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

Ресурсы

• Код XIAOML KIT
• Спектральные признаки DSP
• Проект Edge Impulse
• Блокнот Colab с блоком спектральных признаков Edge Impulse
• Документация Edge Impulse
• Спектральные признаки Edge Impulse
• Библиотека LSM6DS3 от Seeed Studio

Обнаружение объектов

Промпт DALL·E: мультфильм в стиле анимации 1950-х с подробной платой, на которой видны датчики, в первую очередь камера, на столе с узорчатой скатертью. За платой стоит компьютер с большой задней панелью, на котором открыта Arduino IDE. Содержимое IDE намекает на назначение выводов светодиодов и инференс модели машинного обучения для распознавания голосовых команд. Serial Monitor в отдельном окне показывает результаты для команд «yes» и «no».

Обзор

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

Обнаружение объектов и классификация изображений

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

Но что будет, если на изображении нет доминирующей категории?

Модель классификации изображений совершенно неверно определяет это изображение как «ashcan» (мусорный ящик), возможно из-за цветовых оттенков.

Модель, которая использовалась на предыдущих изображениях, — MobileNet, обученная на большом наборе данных ImageNet, работающая на Raspberry Pi.

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

Такие модели гораздо сложнее и крупнее, например MobileNetV2 SSD FPN-Lite 320x320, обученная на наборе COCO. Эта предобученная модель обнаружения объектов умеет находить до 10 объектов на изображении и выдаёт ограничивающий прямоугольник (bounding box) для каждого обнаруженного объекта. Изображение ниже — результат работы такой модели на Raspberry Pi:

Модели для обнаружения объектов (такие как MobileNet SSD или YOLO) обычно занимают несколько мегабайт. Для Raspberry Pi это нормально, но для встраиваемых устройств, где ОЗУ обычно составляет в лучшем случае несколько мегабайт, как у XIAO ESP32S3, такие модели не подходят.

Инновационное решение для обнаружения объектов: FOMO

Edge Impulse представила в 2022 году FOMO (Faster Objects, More Objects) — новое решение для обнаружения объектов на встраиваемых устройствах, таких как Nicla Vision и Portenta (Cortex M7), процессорах Cortex M4F (Arduino Nano33 и серии OpenMV M4), а также устройствах Espressif ESP32 (ESP-CAM, ESP-EYE и XIAO ESP32S3 Sense).

В этом практическом проекте мы будем обнаруживать объекты с помощью FOMO.

Чтобы больше узнать о FOMO, прочитайте официальное объявление FOMO от Edge Impulse, где Louis Moreau и Mat Kelcey подробно объясняют принцип работы.

Цель проекта обнаружения объектов

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

Иначе говоря, нам нужна многоклассовая классификация, где каждое изображение может относиться к трём классам:

• фон (объектов нет);
• фрукт (Fruit);
• жук (Bug).

Вот несколько неразмеченных примеров изображений, по которым мы будем обнаруживать объекты (фрукты и жуков):

Нас интересует, какой объект есть на изображении, его положение (центроид) и сколько таких объектов на нём присутствует. Размер объекта FOMO не определяет — в отличие от MobileNet SSD или YOLO, где ограничивающий прямоугольник является одним из выходных данных модели.

Проект мы будем разрабатывать с использованием XIAO ESP32S3 для захвата изображений и инференса. Проект машинного обучения будет создан в Edge Impulse Studio. Но прежде чем начинать проект обнаружения объектов в Studio, создадим сырой набор данных (без разметки) с изображениями, на которых есть объекты для обнаружения.

Сбор данных

Изображения можно снимать с помощью XIAO, телефона или других устройств. Здесь мы будем использовать XIAO с кодом из библиотеки ESP32 для Arduino IDE.

Сбор набора данных с XIAO ESP32S3

Откройте Arduino IDE и выберите плату XIAO_ESP32S3 (и порт, к которому она подключена). В меню File > Examples > ESP32 > Camera выберите CameraWebServer.

На панели BOARDS MANAGER (менеджер плат) убедитесь, что установлен последний стабильный (stable) пакет.

⚠️ Внимание

Альфа-версии (например, 3.x-alpha) некорректно работают с XIAO и Edge Impulse. Используйте последнюю стабильную версию (например, 2.0.11).

Также закомментируйте все модели камер, кроме выводов модели XIAO:

#define CAMERA_MODEL_XIAO_ESP32S3 // Есть PSRAM

И включите PSRAM в меню Tools. Введите данные Wi-Fi и загрузите код на устройство:

Если код выполнился правильно, в Serial Monitor появится адрес:

Скопируйте адрес в браузер и дождитесь загрузки страницы. Выберите разрешение камеры (например, QVGA) и нажмите [START STREAM]. Подождите несколько секунд или минут в зависимости от качества соединения. Кнопкой [Save] можно сохранить изображение в папку загрузок на компьютере.

Edge Impulse рекомендует, чтобы объекты были похожего размера и не перекрывали друг друга, — так модель работает лучше. На промышленном предприятии это нормально: камера закреплена неподвижно и находится на одном расстоянии от объектов. Тем не менее мы попробуем и смешанные размеры и положения, чтобы посмотреть на результат.

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

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

Сохраняемые изображения имеют размер кадра QVGA $320\times 240$ и формат RGB565 (формат цветных пикселей).

Когда набор данных собран, нажмите [Stop Stream] и переместите изображения в папку.

Edge Impulse Studio

Настройка проекта

Откройте Edge Impulse Studio, войдите в систему по кнопке Login (или создайте аккаунт) и начните новый проект.

Здесь можно клонировать проект, созданный для этой практической работы: XIAO-ESP32S3-Sense-Object_Detection.

На панели проекта Dashboard прокрутите вниз до Project info, выберите Bounding boxes (object detection) и Espressif ESP-EYE (наиболее похожее на нашу плату) в качестве целевого устройства:

Загрузка неразмеченных данных

В Studio откройте вкладку Data acquisition и в разделе UPLOAD DATA загрузите снятые изображения из папки на компьютере.

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

Все неразмеченные изображения (47) загружены, но перед использованием в наборе данных их нужно правильно разметить. Для этого в Studio есть инструмент, который открывается по ссылке Labeling queue (47).

В бесплатной версии Edge Impulse Studio доступны два способа разметки с помощью ИИ:

• с использованием YOLOv5;
• отслеживанием объектов между кадрами.

Для клиентов Enterprise Edge Impulse запустила функцию автоматической разметки, которая упрощает разметку в проектах обнаружения объектов.

Обычные объекты можно быстро распознать и разметить с помощью готовой библиотеки предобученных моделей обнаружения YOLOv5 (обученных на наборе COCO). Но в нашем случае объектов нет в наборах COCO, поэтому выберем опцию tracking objects (отслеживание объектов). С ней, как только вы нарисуете рамки и разметите изображения в одном кадре, объекты будут автоматически отслеживаться от кадра к кадру, и новые объекты будут частично размечены (не все — корректно).

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

Разметка набора данных

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

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

Затем просмотрите размеченные примеры на вкладке Data acquisition. Если какая-то метка неверна, её можно отредактировать через меню «три точки» после названия образца:

Studio подскажет, как заменить неверную метку и исправить набор данных.

Балансировка набора данных и разделение на обучающую и тестовую выборки

После разметки всех данных стало очевидно, что класса «фрукт» гораздо больше, чем «жука». Поэтому собрали 11 дополнительных изображений жуков (всего стало 58). После их разметки нужно отобрать часть изображений в тестовую выборку. Это делается через меню «три точки» после названия изображения. Я отобрал шесть изображений, что составляет 13 % от общего набора данных.

Проектирование Impulse

На этом этапе нужно определить, как:

• Предобработка: изменить размер отдельных изображений с $320\times 240$ до $96\times 96$, сжав их к квадратной форме (без обрезки). Затем изображения переводятся из RGB в оттенки серого (Grayscale).
• Проектирование модели: в данном случае «Object Detection» (обнаружение объектов).

Предобработка всего набора данных

В этом разделе выберите Color depth — Grayscale, подходящий для моделей FOMO, и сохраните параметры (Save parameters).

Studio автоматически переходит к разделу Generate features, где обрабатываются все образцы. В результате получается набор данных из отдельных изображений $96\times 96\times 1$, или 9 216 признаков.

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

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

Проектирование модели, обучение и тестирование

Мы будем использовать FOMO — модель обнаружения объектов на основе MobileNetV2 (альфа 0,35), которая грубо сегментирует изображение на сетку: фон и интересующие объекты (здесь фрукты и жуки).

FOMO — инновационная модель машинного обучения для обнаружения объектов, которая может использовать в 30 раз меньше энергии и памяти, чем традиционные модели вроде Mobilenet SSD и YOLOv5. FOMO способна работать на микроконтроллерах с ОЗУ менее 200 КБ. Главная причина в том, что другие модели вычисляют размер объекта, рисуя вокруг него квадрат (ограничивающий прямоугольник), а FOMO не учитывает размер и выдаёт только информацию о том, где объект находится на изображении, — в виде координат его центроида.

Как работает FOMO

FOMO берёт изображение в оттенках серого и делит его на блоки пикселей с коэффициентом 8. Для входного изображения $96\times 96$ сетка будет $12\times 12$ $(96/8=12)$. Затем FOMO запускает классификатор для каждого блока пикселей, чтобы вычислить вероятность того, что в нём есть фрукт или жук, и определяет области с наибольшей вероятностью наличия объекта (если в блоке пикселей объектов нет, он классифицируется как background). По перекрытию итоговой области FOMO выдаёт координаты (относительно размеров изображения) центроида этой области.

Для обучения нужно выбрать предобученную модель. Используем FOMO (Faster Objects, More Objects) MobileNetV2 0.35. Эта модель занимает около 250 КБ ОЗУ и 80 КБ ПЗУ (флеш-памяти), что хорошо подходит для нашей платы.

Гиперпараметры обучения такие:

• эпох: 60;
• размер батча (batch size): 32;
• скорость обучения (learning rate): 0,001.

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

В итоге модель получает общую F1-меру 85 %, что близко к результату на тестовых данных (83 %).

FOMO автоматически добавил третью метку background к двум заданным ранее (fruit и bug).

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

Проверка модели в режиме «Live Classification»

После обучения модели её можно проверить с помощью инструмента Live Classification. В соответствующем разделе нажмите значок подключения платы разработки (небольшой микроконтроллер) и отсканируйте QR-код телефоном.

После подключения телефон можно использовать для съёмки реальных изображений, которые будет тестировать обученная модель в Edge Impulse Studio.

Учтите, что модель может давать ложные срабатывания и пропуски. Это можно уменьшить, задав подходящий Confidence Threshold (порог уверенности; настройка через меню «три точки»). Попробуйте значение 0,8 и выше.

Развёртывание модели (Arduino IDE)

Выберите Arduino Library и модель Quantized (int8), включите компилятор EON на вкладке Deploy и нажмите [Build].

Откройте Arduino IDE, в меню Sketch выберите Include Library и Add .ZIP Library. Выберите файл, скачанный из Edge Impulse Studio, — и готово!

На вкладке Examples в Arduino IDE под именем вашего проекта вы найдёте скетч (esp32 > esp32_camera).

Нужно изменить строки с 32 по 75, которые задают модель камеры и выводы, используя данные нашей модели. Скопируйте приведённые ниже строки и замените ими строки 32–75:

#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     10
#define SIOD_GPIO_NUM     40
#define SIOC_GPIO_NUM     39
#define Y9_GPIO_NUM       48
#define Y8_GPIO_NUM       11
#define Y7_GPIO_NUM       12
#define Y6_GPIO_NUM       14
#define Y5_GPIO_NUM       16
#define Y4_GPIO_NUM       18
#define Y3_GPIO_NUM       17
#define Y2_GPIO_NUM       15
#define VSYNC_GPIO_NUM    38
#define HREF_GPIO_NUM     47
#define PCLK_GPIO_NUM     13

Вот получившийся код:

Загрузите код на XIAO ESP32S3 Sense — и можно начинать обнаруживать фрукты и жуков. Результат можно проверить в Serial Monitor.

Фон

Фрукты

Жуки

Обратите внимание: задержка модели составляет 143 мс, а частота кадров — около 7 кадров в секунду (примерно как в проекте классификации изображений). Это объясняется тем, что FOMO искусно построена на основе CNN-модели, а не модели обнаружения вроде SSD MobileNet. Например, при запуске модели MobileNetV2 SSD FPN-Lite $320\times 320$ на Raspberry Pi 4 задержка примерно в пять раз выше (около 1,5 кадра в секунду).

Развёртывание модели (SenseCraft Web Toolkit)

Как обсуждалось в главе о классификации изображений, проверка инференса моделей для изображений в Arduino IDE очень затруднительна, потому что мы не видим, на что направлена камера. Поэтому воспользуемся SenseCraft Web Toolkit.

Чтобы запустить SenseCraft Web Toolkit, выполните следующие шаги:

1. Откройте сайт SenseCraft Web Toolkit.
2. Подключите XIAO к компьютеру:

• При подключённом XIAO выберите его, как показано ниже:

• Выберите устройство и порт, затем нажмите [Connect]:

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

В нашем случае мы используем синюю кнопку внизу страницы: [Upload Custom AI Model].

Но сначала нужно скачать из Edge Impulse Studio нашу квантованную модель .tflite.

3. Перейдите в свой проект в Edge Impulse Studio или клонируйте этот:

• XIAO-ESP32S3-CAM-Fruits-vs-Veggies-v1-ESP-NN

4. На вкладке Dashboard скачайте модель («block output»): Object Detection model — TensorFlow Lite (int8 quantized).

5. В SenseCraft Web Toolkit нажмите синюю кнопку внизу страницы: [Upload Custom AI Model]. Откроется окно. Укажите файл модели, скачанный из Edge Impulse Studio, выберите имя модели и введите метки (ID: Object):

Учтите, что нужно использовать метки, заданные в EI Studio, и вводить их в алфавитном порядке (в нашем случае: background, bug, fruit).

Через несколько секунд (или минут) модель загрузится на устройство, и изображение с камеры появится в реальном времени в области предпросмотра (Preview):

Обнаруженные объекты будут отмечены (центроиды). Можно выбрать уверенность инференса курсором Confidence и IoU — меру, которая оценивает точность предсказанных ограничивающих рамок по сравнению с истинными.

Нажав верхнюю кнопку (Device Log), можно открыть Serial Monitor и следить за инференсом, как мы делали в Arduino IDE.

В Device Log вы получите такие данные:

• время предобработки (захват и обрезка изображения): 3 мс;
• время инференса (задержка модели): 115 мс;
• время постобработки (вывод изображения и отметка объектов): 1 мс;
• выходной тензор (рамки), например одна из рамок: [[30, 150, 20, 20, 97, 2]]. Здесь 30, 150, 20, 20 — координаты рамки (вокруг центроида); 97 — результат инференса, а 2 — класс (в данном случае 2: fruit, фрукт).

В приведённом примере получилось 5 рамок, поскольку ни один фрукт не получил по 3 центроида. Одно из решений — постобработка, при которой близкие центроиды объединяются в один.

Ещё несколько снимков экрана:

Итоги

FOMO — важный скачок в области обработки изображений, как сказали Louis Moreau и Mat Kelcey при её запуске в 2022 году:

FOMO — революционный алгоритм, который впервые приносит обнаружение, отслеживание и подсчёт объектов в реальном времени на микроконтроллеры.

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

Ресурсы

• Проект Edge Impulse

Настройка

Промпт DALL·E: рисунок в стиле мультфильма 1950-х с платой XIAO ESP32S3 с характерным модулем камеры, как на предоставленном изображении. Плата стоит на классическом лабораторном столе среди различных датчиков, включая микрофон. За платой — старинный экран компьютера с Arduino IDE в приглушённых цветах; код посвящён настройке выводов светодиодов и инференсу модели машинного обучения для голосовых команд. Serial Monitor в IDE показывает распознанные команды «yes» и «no». Сцена сочетает ретро-шарм лабораторий середины века с современной электроникой.

Обзор

XIAOML Kit предназначен для практического знакомства с приложениями TinyML. В комплект входят мощная отладочная плата XIAO ESP32S3 Sense и плата расширения, которая добавляет датчики, необходимые для проектов машинного обучения.

Состав комплекта XIAOML Kit:

• XIAO ESP32S3 Sense: основная отладочная плата со встроенной камерой, цифровым микрофоном и поддержкой SD-карт;
• Плата расширения: содержит 6-осевой IMU (LSM6DS3TR-C) и 0,42-дюймовый OLED-дисплей для регистрации движения и визуализации данных;
• Набор для работы с SD-картой: включает SD-карту и адаптер USB для хранения данных и развёртывания моделей;
• Кабель USB-C: для подключения платы к компьютеру;
• Антенна и радиаторы.

⚠️ Внимание

Не устанавливайте радиаторы на плату XIAO ESP32S3 (или снимите их аккуратно), если хотите использовать плату расширения XIAO ML Kit. Подробнее см. в приложении.

Основные особенности платы XIAO ESP32S3 Sense

XIAO ESP32S3 Sense — сердце комплекта XIAOML Kit. Она объединяет вычислительные возможности для ML с фото- и аудиофункциями и подходит для проектов TinyML в области интеллектуального голосового и визуального ИИ.

Ключевые особенности

• Мощный микроконтроллер: 32-разрядный двухъядерный процессор ESP32S3 с архитектурой Xtensa, работающий на частоте до 240 МГц, с поддержкой Arduino и MicroPython;
• Расширенные функции: съёмная камера OV2640 с разрешением $1600\times 1200$, совместимая с камерой OV5640, а также встроенный цифровой микрофон;
• Продуманное питание: управление зарядом литиевой батареи, четыре режима энергопотребления, режим глубокого сна с потреблением всего 14 мкА;
• Достаточно памяти: 8 МБ PSRAM и 8 МБ флеш-памяти, слот для SD-карты до 32 ГБ (FAT);
• Отличные радиохарактеристики: двойная беспроводная связь Wi-Fi 2,4 ГГц и BLE, дальность связи более 100 м при использовании антенны с разъёмом U.FL;
• Компактный корпус: $21\times 17,5$ мм, классический форм-фактор XIAO, удобный для проектов с ограниченным местом.

Ниже показана общая распиновка платы:

Подробности см. на вики Seeed Studio.

Особенности платы расширения

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

Компоненты:

• 6-осевой IMU (LSM6DS3TR-C):

  • 3-осевой акселерометр и 3-осевой гироскоп для обнаружения и классификации движения;
    • диапазон акселерометра: ±2/±4/±8/±16 g;
    • диапазон гироскопа: ±125/±250/±500/±1000/±2000 dps;
    • интерфейс I2C (адрес: 0x6A).

• 0,42-дюймовый OLED-дисплей:

  • монохромный дисплей (разрешение $72\times 40$) для визуализации данных в реальном времени;
    • контроллер: SSD1306;
    • интерфейс I2C (адрес: 0x3C).

• Кнопка перезапуска (EN);

• Разъём аккумулятора (BAT+, BAT−).

Сборка комплекта

Плата расширения легко подключается к XIAO ESP32S3 Sense, образуя универсальную платформу для мультимодальных экспериментов с машинным обучением: зрение, звук и движение.

Обратите внимание на ориентацию установки модуля:

Обратите внимание:

• соединение EN, которое находится внизу ESP32S3 Sense, доступно на плате расширения через кнопку RST;
• соединения BAT+ и BAT- также доступны через белый разъём BAT3.7V.

Применения XIAOML Kit:

• Зрение: классификация изображений и обнаружение объектов с помощью встроенной камеры;
• Звук: распознавание ключевых слов и голосовых команд со встроенным микрофоном;
• Движение: распознавание активности и обнаружение аномалий с помощью датчиков IMU;
• Мультимодальность: комплексное слияние данных датчиков для сложных приложений ML.

Установка XIAO ESP32S3 Sense в Arduino IDE

1. Подключите XIAOML Kit к компьютеру через порт USB-C.

2. Скачайте и установите стабильную версию Arduino IDE для вашей операционной системы.

   [Скачать Arduino IDE]

3. Откройте Arduino IDE и выберите Boards Manager (менеджер плат), который обозначен значком UNO.

4. Введите «ESP32» и выберите «esp32 by Espressif Systems». Можно установить или обновить пакеты поддержки плат.

Не выбирайте «Arduino ESP32 Boards by Arduino»: это пакет поддержки Arduino Nano ESP32, а не нашей платы.

⚠️ Внимание

Версии 3.x могут создавать проблемы при использовании XIAO ESP32S3 Sense с кодом развёртывания Edge Impulse. Если это так, используйте последнюю стабильную версию 2.0.x (например, 2.0.17).

5. Нажмите Select Board, введите xiao или esp32s3, выберите XIAO_ESP32S3 в менеджере плат и соответствующий порт PORT, к которому подключена ESP32S3.

Готово! Плата должна работать. Проведём несколько тестов.

Проверка платы: мигание светодиодом (Blink)

На плате XIAO ESP32S3 Sense есть встроенный светодиод, подключённый к GPIO21. Поэтому можно запустить скетч Blink, который находится в File/Examples/Basics/Blink. Скетч использует константу Arduino LED_BUILTIN, которая внутри соответствует светодиоду на выводе 21. Или можно изменить скетч Blink вручную:

#define LED_BUILT_IN 21 // Эта строка необязательна

void setup() {
  pinMode(LED_BUILT_IN, OUTPUT); // Настраиваем вывод на выход
}

// Помните, что выводы работают с инверсной логикой:
// LOW — включить, HIGH — выключить
void loop() {
  digitalWrite(LED_BUILT_IN, LOW); // Включить
  delay (1000); // Ждать 1 секунду
  digitalWrite(LED_BUILT_IN, HIGH); // Выключить
  delay (1000); // Ждать 1 секунду
}

Обратите внимание: выводы работают с инверсной логикой — LOW включает светодиод, HIGH выключает.

Проверка микрофона

Начнём с обнаружения звука. Введите код ниже или перейдите в проект на GitHub и скачайте скетч XIAOML_Kit_Mic_Test, затем запустите его в Arduino IDE:

/*
  Простой тест микрофона XIAO ESP32S3
  (для библиотеки ESP32 версии 3.0.x и новее)
*/

#include <ESP_I2S.h>
I2SClass I2S;

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    }

  // Настройка тактового сигнала PDM на выводе 42 и данных PDM на выводе 41
  I2S.setPinsPdmRx(42, 41);

  // Запуск I2S с частотой 16 кГц и 16 битами на отсчёт
  if (!I2S.begin(I2S_MODE_PDM_RX,
                 16000,
                 I2S_DATA_BIT_WIDTH_16BIT,
                 I2S_SLOT_MODE_MONO)) {
    Serial.println("Failed to initialize I2S!");
    while (1); // ничего не делать
  }
}

void loop() {
  // Считываем отсчёт
  int sample = I2S.read();

  if (sample && sample != -1 && sample != 1) {
    Serial.println(sample);
  }
}

Откройте Serial Plotter — вы увидите кривую изменения громкости звука.

Когда вы издаёте звуки, изменения сигнала видны в Serial Plotter.

Сохранение записанного звука (аудиофайлы .wav) на microSD-карту.

Теперь с помощью встроенного считывателя SD-карт можно сохранять аудиофайлы .wav. Для этого сначала нужно включить PSRAM на XIAO.

У ESP32-S3 на чипе микроконтроллера всего несколько сотен килобайт внутренней оперативной памяти. Этого может не хватить для некоторых задач, поэтому к флеш-чипу SPI можно подключить до 16 МБ внешней PSRAM (псевдостатического ОЗУ). На XIAO установлено 8 МБ PSRAM. Внешняя память включена в адресное пространство процессора и при определённых ограничениях может использоваться так же, как внутренняя оперативная память данных.

• Чтобы её включить, откройте Tools->PSRAM:"OPI PSRAM"->OPI PSRAM.

XIAO ESP32S3 Sense поддерживает microSD-карты объёмом до 32 ГБ. Если вы собираетесь купить microSD-карту для XIAO, выбирайте карту объёмом не более 32 ГБ. Перед использованием отформатируйте microSD-карту в FAT32.

Теперь вставьте отформатированную в FAT32 SD-карту в XIAO, как показано на фото:

/*
 * Диктофон WAV для Seeed XIAO ESP32S3 Sense
 * (для библиотеки ESP32 версии 3.0.x и новее)
*/

#include "ESP_I2S.h"
#include "FS.h"
#include "SD.h"

void setup() {
  // Создаём экземпляр I2SClass
  I2SClass i2s;

  // Переменные для хранения аудиоданных
  uint8_t *wav_buffer;
  size_t wav_size;

  // Инициализация последовательного порта
  Serial.begin(115200);
  while (!Serial) {
    delay(10);
  }

  Serial.println("Initializing I2S bus...");

  // Настройка выводов для аудиовхода
  i2s.setPinsPdmRx(42, 41);

  // Запуск I2S с частотой 16 кГц и 16 битами на отсчёт
  if (!i2s.begin(I2S_MODE_PDM_RX,
                 16000,
                 I2S_DATA_BIT_WIDTH_16BIT,
                 I2S_SLOT_MODE_MONO)) {
    Serial.println("Failed to initialize I2S!");
    while (1); // ничего не делать
  }

  Serial.println("I2S bus initialized.");
  Serial.println("Initializing SD card...");

  // Настройка выводов для доступа к SD-карте
  if(!SD.begin(21)){
    Serial.println("Failed to mount SD Card!");
    while (1) ;
  }
  Serial.println("SD card initialized.");
  Serial.println("Recording 20 seconds of audio data...");

  // Запись 20 секунд аудиоданных
  wav_buffer = i2s.recordWAV(20, &wav_size);

  // Создаём файл на SD-карте
  File file = SD.open("/arduino_rec.wav", FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open file for writing!");
    return;
  }

  Serial.println("Writing audio data to file...");

  // Записываем аудиоданные в файл
  if (file.write(wav_buffer, wav_size) != wav_size) {
    Serial.println("Failed to write audio data to file!");
    return;
  }

  // Закрываем файл
  file.close();

  Serial.println("Application complete.");
}

void loop() {
  delay(1000);
  Serial.printf(".");
}

• Сохраните код, например, как Wav_Record.ino, и запустите его в Arduino IDE.
• Эта программа выполняется только один раз после того, как пользователь откроет Serial Monitor (или нажмёт кнопку RESET). Она записывает 20 секунд и сохраняет файл на microSD-карту под именем «arduino_rec.wav».
• Когда в Serial Monitor каждую секунду появляется «.», выполнение программы завершено, и записанный звуковой файл можно воспроизвести, подключив карту через считыватель.

Качество звука отличное!

Принцип работы кода выходит за рамки этой лабораторной работы, но подробное описание есть на вики.

Подробнее о файловой системе XIAO ESP32S3 Sense — по этой ссылке.

Проверка камеры

Для проверки и использования камеры можно применять несколько способов:

• SenseCraft AI Studio;
• приложение CameraWebServer в Arduino IDE (см. следующий раздел);
• захват изображений и сохранение их на SD-карту (аналогично тому, что мы делали со звуком).

Проверка камеры в SenseCraft AI Studio

Самый простой способ увидеть работу камеры — использовать SenseCraft AI Studio, надёжную платформу, которая предлагает широкий набор моделей ИИ для разных устройств, включая XIAO ESP32S3 Sense и Grove Vision AI V2.

Также можно воспользоваться SenseCraft Web Toolkit — упрощённой версией SenseCraft AI Studio.

Чтобы запустить SenseCraft AI, выполните следующие шаги:

• Откройте рабочее пространство SenseCraft AI Vision в веб-браузере, например Chrome, и войдите в систему (или создайте аккаунт).

• Подключите XIAOML Kit к ноутбуку и выберите его, как показано ниже:

Примечание: инструмент WebUSB может работать некорректно в некоторых браузерах, например в Safari. Используйте Chrome. Также убедитесь, что Arduino IDE или любое другое последовательное устройство не подключено к XIAO.

Чтобы увидеть работу камеры, нужно загрузить модель. Можно попробовать несколько моделей компьютерного зрения, заранее загруженных Seeed Studio. Нажмите кнопку [Select Model] и выберите одну из доступных моделей.

Наведя курсор на модели ИИ, можно увидеть их название, описание, категорию или задачу (классификация изображений, обнаружение объектов или определение позы/ключевых точек), алгоритм (например, YOLO V5 или V8, FOMO, MobileNet V2 и т. д.), а в некоторых случаях и метрики (точность или mAP).

Можно выбрать одну из готовых моделей, например «Person Classification», нажав на неё и затем кнопку [Confirm], или загрузить собственную модель.

В области Preview мы видим видеопоток с камеры.

Мы подробнее вернёмся к SenseCraft AI Studio в лабораторных работах по компьютерному зрению.

Проверка Wi-Fi

Установка антенны

Комплект XIAOML Kit приходит полностью собранным. Сначала снимите плату расширения Sense (на ней камера, микрофон и считыватель SD-карт) с XIAO.

В левом нижнем углу передней стороны XIAO ESP32S3 есть отдельный разъём «WiFi/BT Antenna Connector». Чтобы улучшить сигнал Wi-Fi и Bluetooth, достаньте антенну из упаковки и прикрепите её к разъёму.

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

Снимается антенна так же: не тяните её силой напрямую, а поднимите с одной стороны, и тогда её будет легко снять.

Установить плату расширения обратно очень просто: совместите разъём платы расширения с разъёмом B2B на XIAO ESP32S3, сильно надавите и услышите «щелчок». Установка завершена.

Одна из отличительных черт XIAO ESP32S3 — возможности Wi-Fi. Проверим радиомодуль, сканируя окружающие сети Wi-Fi. Для этого запустите один из примеров кода на плате.

Откройте Arduino IDE, выберите нашу плату и порт. Перейдите в Examples и найдите WiFi > WiFiScan в разделе «Examples for the XIAO ESP32S3». Загрузите скетч на плату.

В Serial Monitor вы должны увидеть сети Wi-Fi (SSID и RSSI) в радиусе действия вашего устройства. Вот что получилось у нас в лаборатории:

Простой Wi-Fi-сервер (включение и выключение светодиода)

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

Перейдите в Examples и найдите WiFi > SimpleWiFiServer в разделе «Examples for the XIAO ESP32S3».

Перед запуском скетча введите данные своей сети:

const char* ssid     = "Your credentials here";
const char* password = "Your credentials here";

Затем измените вывод 5 на вывод 21, к которому подключён встроенный светодиод. Также измените веб-страницу (строки 85 и 86), чтобы отразить правильный вывод светодиода и то, что он включается сигналом LOW:

client.print("Click <a href=\"/H\">here</a> to turn the LED on pin 21 OFF.<br>");
client.print("Click <a href=\"/L\">here</a> to turn the LED on pin 21 ON.<br>");

Работу сервера можно отслеживать через Serial Monitor.

Возьмите IP-адрес из Serial Monitor и введите его в браузере. Откроется страница со ссылками, которые включают и выключают встроенный светодиод XIAO.

Использование CameraWebServer

В Arduino IDE откройте File > Examples > ESP32 > Camera и выберите CameraWebServer.

На вкладке board_config.h закомментируйте все модели камер, кроме выводов модели XIAO:

#define CAMERA_MODEL_XIAO_ESP32S3 // Есть PSRAM

Не забудьте проверить в меню Tools, включена ли PSRAM.

Как и раньше, на вкладке CameraWebServer.ino введите данные Wi-Fi и загрузите код на устройство.

Если код выполнился правильно, в Serial Monitor появится адрес:

WiFi connecting....
WiFi connected
Camera Ready! Use 'http://192.168.5.60' to connect

Скопируйте адрес в браузер и дождитесь загрузки страницы. Выберите разрешение камеры (например, QVGA) и нажмите [START STREAM]. Подождите несколько секунд в зависимости от качества соединения. Кнопкой [Save] можно сохранить изображение в папку загрузок на компьютере.

Вот и всё! Изображения можно сохранить прямо на компьютер и использовать в проектах.

Проверка датчика IMU (LSM6DS3TR-C)

Инерциальный измерительный блок (IMU) — датчик, который измеряет движение и ориентацию. LSM6DS3TR-C на вашем XIAOML Kit — это 6-осевой IMU, то есть он объединяет:

• 3-осевой акселерометр: измеряет линейное ускорение (включая силу тяжести) по осям X, Y и Z;
• 3-осевой гироскоп: измеряет угловую скорость (скорость вращения) вокруг осей X, Y и Z.

Технические характеристики

• Связь: интерфейс I2C, адрес 0x6A;
• Диапазон акселерометра: ±2/±4/±8/±16 g (по умолчанию используем ±2 g);
• Диапазон гироскопа: ±125/±250/±500/±1000/±2000 dps (по умолчанию используем ±250 dps);
• Разрешение: 16-битный АЦП;
• Энергопотребление: сверхнизкое.

Система координат

Датчик использует правостороннюю систему координат. Если смотреть на датчик IMU с видимой меткой (вид платы расширения снизу):

• Ось X: направлена вправо;
• Ось Y: направлена вперёд (от вас);
• Ось Z: направлена вверх (из платы).

Необходимые библиотеки

Перед загрузкой кода установите нужную библиотеку:

1. Откройте Arduino IDE и выберите Manage Libraries (менеджер библиотек), который обозначен значком Books Icon.

2. Для библиотеки IMU введите «LSM6DS3» и выберите «Seeed Arduino LSM6DS3 by Seeed». Можно INSTALL (установить) или UPDATE (обновить).

⚠️ Важно: НЕ устанавливайте «Arduino_LSM6DS3 by Arduino» — она предназначена для других плат!

Тестовый код

Введите приведённый ниже код в Arduino IDE и загрузите его в комплект:

#include <LSM6DS3.h>
#include <Wire.h>

// Создаём объект IMU через интерфейс I2C
// Датчик LSM6DS3TR-C находится по адресу I2C 0x6A
LSM6DS3 myIMU(I2C_MODE, 0x6A);

// Переменные для хранения показаний датчика
float accelX, accelY, accelZ;  // Значения акселерометра (перегрузка в g)
float gyroX, gyroY, gyroZ;     // Значения гироскопа (градусы в секунду)

void setup() {
  // Инициализация последовательной связи со скоростью 115200 бод
  Serial.begin(115200);

  // Ждём подключения последовательного порта (полезно для отладки)
  while (!Serial) {
    delay(10);
  }

  Serial.println("XIAOML Kit IMU Test");
  Serial.println("LSM6DS3TR-C 6-Axis IMU Sensor");
  Serial.println("=============================");

  // Инициализация датчика IMU
  if (myIMU.begin() != 0) {
    Serial.println("ERROR: IMU initialization failed!");
    Serial.println("Check connections and I2C address");
    while(1) {
      delay(1000); // Останавливаем выполнение, если IMU не инициализировался
    }
  } else {
    Serial.println("✓ IMU initialized successfully");
    Serial.println();

    // Вывод информации о датчике
    Serial.println("Sensor Information:");
    Serial.println("- Accelerometer range: ±2g");
    Serial.println("- Gyroscope range: ±250 dps");
    Serial.println("- Communication: I2C at address 0x6A");
    Serial.println();

    // Вывод описания формата данных
    Serial.println("Data Format:");
    Serial.println("AccelX,AccelY,AccelZ,GyroX,GyroY,GyroZ");
    Serial.println("Units: g-force (m/s²), degrees/second");
    Serial.println();

    delay(2000); // Короткая пауза перед началом измерений
  }
}

void loop() {
  // Считываем данные акселерометра (в единицах g)
  accelX = myIMU.readFloatAccelX();
  accelY = myIMU.readFloatAccelY();
  accelZ = myIMU.readFloatAccelZ();

  // Считываем данные гироскопа (в градусах в секунду)
  gyroX = myIMU.readFloatGyroX();
  gyroY = myIMU.readFloatGyroY();
  gyroZ = myIMU.readFloatGyroZ();

  // Вывод в удобном формате в Serial Monitor
  Serial.print("Accelerometer (g): ");
  Serial.print("X="); Serial.print(accelX, 3);
  Serial.print(" Y="); Serial.print(accelY, 3);
  Serial.print(" Z="); Serial.print(accelZ, 3);

  Serial.print(" | Gyroscope (°/s): ");
  Serial.print("X="); Serial.print(gyroX, 2);
  Serial.print(" Y="); Serial.print(gyroY, 2);
  Serial.print(" Z="); Serial.print(gyroZ, 2);
  Serial.println();

  // Вывод в формате CSV для Serial Plotter
  Serial.println(String(accelX) + "," + String(accelY) + "," +
                 String(accelZ) + "," + String(gyroX) + "," +
                 String(gyroY) + "," + String(gyroZ));

  // Частота обновления: 10 Гц (задержка 100 мс)
  delay(100);
}

Serial Monitor покажет значения, а Plotter — их изменение во времени. Например, если перемещать комплект по оси Y, будет меняться значение 2 (красная линия). Ось Z представлена значением 3 (зелёная линия), которое близко к 1,0 g. Синяя линия (значение 1) относится к оси X.

Значения с 4 по 6 можно выбрать, чтобы увидеть поведение гироскопа.

Проверка OLED-дисплея (SSD1306)

OLED-дисплеи (Organic Light-Emitting Diode) — экраны с самосвечением, где каждый пиксель излучает собственный свет. Компактный 0,42-дюймовый монохромный OLED-дисплей XIAO ML kit подходит для вывода данных датчиков, информации о состоянии и простой графики.

Технические характеристики

• Размер: 0,42 дюйма по диагонали;
• Разрешение: $72\times 40$ пикселей;
• Контроллер: SSD1306;
• Интерфейс: I2C, адрес 0x3C;
• Цвет: монохромный (чёрные пиксели на белом фоне или наоборот);
• Читаемость: высокий контраст, видно даже при ярком освещении;
• Питание: низкое энергопотребление, подсветка не нужна.

Характеристики дисплея

• Точность пикселей: каждым из 2 880 пикселей ($72\times 40$) можно управлять отдельно;
• Быстрое обновление: подходит для анимации и данных в реальном времени;
• Без послесвечения: мгновенный отклик пикселей;
• Широкий угол обзора: изображение читается с разных позиций.

Необходимые библиотеки

Перед загрузкой кода установите нужную библиотеку:

1. Откройте Arduino IDE и выберите «Manage Libraries» (менеджер библиотек), который обозначен значком Books Icon.

2. Введите u8g2 и выберите U8g2 by oliver. Можно install (установить) или update (обновить) пакеты.

   ℹ️ Примечание: U8g2 — мощная графическая библиотека, которая поддерживает множество типов дисплеев.

Библиотека U8g2 — монохромная графическая библиотека со следующими возможностями:

• поддержка множества контроллеров дисплеев (включая SSD1306);
• вывод текста различными шрифтами;
• графические примитивы (линии, прямоугольники, окружности);
• экономичный постраничный рендеринг;
• аппаратная и программная поддержка I2C.

Тестовый код

Введите приведённый ниже код в Arduino IDE и загрузите его в комплект:

#include <U8g2lib.h>
#include <Wire.h>

// Инициализация OLED-дисплея
// Контроллер SSD1306, разрешение 72x40, интерфейс I2C
U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R2, U8X8_PIN_NONE);

void setup() {
  Serial.begin(115200);

  Serial.println("XIAOML Kit - Hello World");
  Serial.println("==========================");

  // Инициализация дисплея
  u8g2.begin();

  Serial.println("✓ Display initialized");
  Serial.println("Showing Hello World message...");

  // Очистка дисплея
  u8g2.clearDisplay();
}

void loop() {
  // Начало последовательности рисования
  u8g2.firstPage();
  do {
    // Выбор шрифта
    u8g2.setFont(u8g2_font_ncenB08_tr);

    // Вывод «Hello World» по центру
    u8g2.setCursor(8, 15);
    u8g2.print("Hello");

    u8g2.setCursor(12, 30);
    u8g2.print("World!");

    // Простое оформление — рамка вокруг текста
    u8g2.drawFrame(2, 2, 68, 36);

  } while (u8g2.nextPage());

  // Задержка не нужна — дисплей будет показывать изображение постоянно
}

Если всё работает правильно, на дисплее вы увидите надпись «Hello World» внутри прямоугольника.

Размеры и позиционирование текста на OLED

• Текст позиционируется функцией setCursor(x, y), в данном случае по центру:

  u8g2.setCursor(8, 15);
  

• В коде используется шрифт среднего размера:

  u8g2.setFont(u8g2_font_ncenB08_tr);
  

  Но доступны и другие размеры шрифта:

  • u8g2_font_4x6_tr: очень маленький шрифт ($4\times 6$ пикселей);
  • u8g2_font_6x10_tr: маленький шрифт ($6\times 10$ пикселей);
  • u8g2_font_ncenB08_tr: средний полужирный шрифт;
  • u8g2_font_ncenB14_tr: крупный полужирный шрифт.

Фигуры

В коде добавлено простое оформление: рамка вокруг текста.

u8g2.drawFrame(2, 2, 68, 36);

Доступны и другие фигуры:

• Контур прямоугольника: drawFrame(x, y, width, height);
• Закрашенный прямоугольник: drawBox(x, y, width, height);
• Окружность: drawCircle(x, y, radius);
• Линия: drawLine(x1, y1, x2, y2);
• Отдельные пиксели: drawPixel(x, y).

Координаты

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

• начало координат (0,0): верхний левый угол;
• ось X: возрастает слева направо (от 0 до 71);
• ось Y: возрастает сверху вниз (от 0 до 39);
• позиционирование текста: setCursor(x, y), где y — базовая линия текста.

Поворот дисплея

Параметр поворота можно изменить:

• U8G2_R0: обычная ориентация;
• U8G2_R1: поворот на 90° по часовой стрелке;
• U8G2_R2: 180° (перевёрнуто);
• U8G2_R3: поворот на 270° по часовой стрелке.

Собственные символы

// Рисуем собственное растровое изображение
static const unsigned char myBitmap[] = {0x00, 0x3c, 0x42, 0x42, 0x3c, 0x00};
u8g2.drawBitmap(x, y, 1, 6, myBitmap);

Измерение текста

int width = u8g2.getStrWidth("Hello");  // Ширина текста
int height = u8g2.getAscent();         // Высота шрифта

OLED-дисплей готов показывать данные датчиков, состояние системы или любую графику, которую вы создадите для своих проектов ML!

Итоги

XIAOML Kit с ESP32S3 Sense — мощная и доступная отправная точка в мир TinyML и встраиваемого машинного обучения. В ходе настройки мы последовательно проверили каждый компонент XIAOML Kit и убедились, что все датчики и периферийные устройства работают правильно. Двухъядерный процессор ESP32S3 и 8 МБ PSRAM обеспечивают достаточную вычислительную мощность для инференса в реальном времени, а камера OV2640, цифровой микрофон, IMU LSM6DS3TR-C и 0,42-дюймовый OLED-дисплей составляют полноценную мультимодальную платформу для сбора данных. Возможности Wi-Fi открывают путь к рабочим процессам ML от периферии к облаку, а среда разработки Arduino IDE теперь настроена со всеми необходимыми библиотеками.

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

Этот процесс настройки демонстрирует ключевые принципы, которые выходят далеко за рамки этого конкретного комплекта. Работа с ограничениями памяти и возможностями обработки ESP32S3 даёт реальный опыт работы с ресурсными ограничениями периферийного ИИ — теми же, что возникают при развёртывании моделей на смартфонах, устройствах IoT или автономных системах. Наличие нескольких модальностей (зрение, звук, движение) на одной платформе позволяет исследовать мультимодальные подходы к машинному обучению, которые всё важнее в реальных приложениях ИИ.

Главное: от сырых данных датчиков до инференса модели и обратной связи через OLED-дисплей комплект воплощает полный цикл развёртывания ML в миниатюре, повторяя трудности, с которыми сталкиваются промышленные системы ИИ.

С этой основой вы готовы решать основные задачи TinyML в следующих главах:

• Проекты по зрению: использование камеры для классификации изображений и обнаружения объектов;
• Звуковые проекты: обработка аудиопотоков для распознавания ключевых слов и голосовых команд;
• Проекты по движению: использование данных IMU для распознавания активности и обнаружения аномалий.

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

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

Ресурсы

• Код XIAOML Kit
• Руководство и примеры кода для XIAO ESP32S3 Sense
• Использование микрофона Seeed Studio XIAO ESP32S3
• Файловая система и XIAO ESP32S3 Sense
• Использование камеры в Seeed Studio XIAO ESP32S3 Sense

Приложение: радиаторы

Соображения о радиаторах

Если вам нужно использовать XIAO ESP32S3 Sense для задач с камерой БЕЗ платы расширения, можно установить радиатор.

Учтите: если радиатор установлен, подключить XIAO ESP32S3 Sense к плате расширения будет невозможно.

Установка радиатора

Чтобы обеспечить оптимальное охлаждение XIAO ESP32S3 Sense, во время работы с камерой следует установить входящий в комплект радиатор. Его конструкция специально рассчитана на охлаждение, особенно при интенсивных операциях, таких как работа с камерой.

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

Установка:

• Перед началом убедитесь, что устройство выключено и отключено от любого источника питания.
• В первую очередь закройте радиатором термопрокладку (THERMAL PAD), которая находится прямо над чипом ESP32S3 — главным источником тепла. Правильное выравнивание обеспечивает оптимальный отвод тепла, и важно, чтобы контакты BAT оставались максимально свободными.

Теперь начнём установку:

Шаг 1. Подготовьте радиатор: снимите защитную плёнку с радиатора, чтобы открыть термоклей. Это подготовит радиатор к надёжному креплению на чипе ESP32S3.

Шаг 2. Соберите радиатор:

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

Если одного радиатора недостаточно, можно установить второй, оба будут использовать одну термопрокладку. Но в этом случае учтите, что все контакты станут недоступны.

⚠️ Внимание

Аккуратно снимите радиаторы перед тем, как снова использовать плату расширения IMU.

Обзор

Эти лабораторные работы дают возможность получить практический опыт работы с системами машинного обучения (ML) на мощном, но компактном встраиваемом устройстве — Seeed Studio Grove Vision AI V2. В отличие от работы с большими моделями, которым нужны ресурсы уровня дата-центра, эти упражнения позволяют напрямую работать с оборудованием и программным обеспечением с помощью TinyML. Такой практический подход даёт осязаемое понимание проблем и возможностей развёртывания ИИ, пусть и в небольшом масштабе. При этом принципы в целом те же, что и при работе с более крупными или, наоборот, ещё более мелкими системами.

Grove Vision AI V2 занимает особое место в мире встраиваемого ИИ: он заполняет разрыв между простыми решениями на микроконтроллерах, такими как Seeed XIAO ESP32S3 Sense или Arduino Nicla Vision, и более мощными одноплатными компьютерами, например Raspberry Pi. В основе платы лежит процессор Himax WiseEye2 HX6538 с двухъядерным Arm Cortex-M55 и встроенным блоком нейронных сетей Arm Ethos-U55.

Arm Ethos-U55 — это специализированный процессор для машинного обучения, класса микро-NPU, который ускоряет инференс ML во встраиваемых и IoT-устройствах с ограниченной площадью кристалла. Сочетание Ethos-U55 с процессором Cortex-M55, рассчитанным на ИИ, даёт прирост производительности ML в 480 раз по сравнению с существующими системами на базе Cortex-M. Работая на частоте 400 МГц с настраиваемой внутренней системной памятью (SRAM) объёмом до 2,4 МБ, Grove Vision AI V2 предлагает возможности компьютерного зрения профессионального уровня и при этом сохраняет энергоэффективность и компактность, необходимые для периферийных приложений.

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

Grove - Vision AI Module V2. Источник: SEEED Studio.

Где купить

Grove Vision AI V2 продаётся в Seeed Studio:

• Grove Vision AI V2 (Seeed Studio) (~$25)

Вам также понадобятся совместимый модуль камеры (Raspberry Pi OV5647) и, при желании, управляющая плата, например XIAO ESP32S3.

Предварительные требования

• Плата Grove Vision AI V2: убедитесь, что плата у вас есть.
• Модуль камеры Raspberry Pi OV5647: камера должна быть подключена к плате Grove Vision AI V2 для захвата изображений.
• Управляющий контроллер: может быть Seeed XIAO ESP32S3, XIAO ESP32C6 или другое устройство.
• Кабель USB-C: для подключения платы к компьютеру.
• Сеть: доступ в интернет для загрузки необходимого программного обеспечения.
• Базовая плата расширения XIAO: помогает подключить управляющее устройство к физическому миру (необязательно).

Настройка и приложения без кода

• Настройка и приложения без кода

Упражнения

Классификация изображений

С использованием Seeed Studio Grove Vision AI Module V2 (Himax WiseEye2)

В этой лабораторной работе мы исследуем классификацию изображений с помощью Grove Vision AI Module V2 от Seeed Studio — мощного, но компактного устройства, созданного специально для приложений встраиваемого машинного обучения. Модуль построен на микросхеме Himax WiseEye2 и предназначен для работы ИИ на периферийных устройствах, поэтому он идеально подходит для задач периферийного машинного обучения (Edge ML).

Введение

До сих пор мы исследовали несколько моделей компьютерного зрения, которые Seeed Studio загрузила заранее, либо использовали SenseCraft AI Studio для классификации изображений, не выбирая конкретную модель. Теперь создадим проект классификации изображений с нуля: сами выберем данные и модель.

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

Цель проекта

Первый шаг любого проекта машинного обучения (ML) — определить цель. В данном случае нужно обнаружить и классифицировать два конкретных объекта, присутствующих на одном изображении. Для проекта мы возьмём две небольшие игрушки: робота и маленького бразильского попугайчика (по имени Periquito). Также соберём изображения фона, на котором этих двух объектов нет.

Сбор данных

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

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

Если вы хотите использовать Grove Vision AI V2 для съёмки набора данных, можно воспользоваться SenseCraft AI Studio, как в предыдущей лабораторной работе, или скетчем camera_web_server, который мы опишем позже в разделе «Постобработка / Получение видеопотока» этой работы.

В этой лабораторной работе для сбора набора данных мы будем использовать SenseCraft AI Studio.

Сбор данных в SenseCraft AI Studio

В SenseCraft AI Studio откройте вкладку Training.

По умолчанию обучается модель Classification с веб-камерой, если она доступна. Выберем вместо неё Grove Vision AI V2. Нажмите зелёную кнопку [Connect] (1) — появится всплывающее окно. Выберите нужный порт (2) и нажмите синюю кнопку [Connect] (3).

На экране появится изображение, которое передаёт Grove Vision AI V2.

Сбор изображений

Создадим классы, например, в алфавитном порядке:

• Класс 1: background (фон)
• Класс 2: periquito (попугайчик)
• Класс 3: robot (робот)

Выберите один из классов (вокруг окна появится зелёная рамка) и удерживайте зелёную кнопку под областью предпросмотра. Собранные изображения появятся на экране выборки (Image Samples).

После сбора изображений просмотрите их и при необходимости удалите некорректные.

Соберите примерно по 50 изображений для каждого класса. Когда все три класса готовы, откройте меню каждого из них и выберите Export Data.

В папке загрузок компьютера появятся три ZIP-архива — по одному на каждый класс. Каждый архив содержит папку с изображениями.

Загрузка набора данных в Edge Impulse Studio

Для обучения модели мы будем использовать Edge Impulse Studio. Edge Impulse — ведущая платформа для разработки моделей машинного обучения на периферийных устройствах.

• Войдите в Edge Impulse с вашими учётными данными (или создайте бесплатный аккаунт).
• Затем создайте новый проект:

Набор данных содержит примерно по 50 изображений на метку: 40 для обучения и 10 для тестирования.

Проектирование Impulse и предобработка

Проектирование Impulse

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

Классификация изображений — самое распространённое применение глубокого обучения, но для неё нужен большой объём данных. У нас около 50 изображений на каждую категорию. Достаточно ли этого? Совсем нет! Чтобы «научить» модель различать каждый класс, нужны тысячи изображений. Однако эту проблему можно решить, дообучив уже обученную модель на небольшом наборе данных. Такой приём называется «переносом обучения» (Transfer Learning, TL). С TL можно донастроить предобученную модель классификации изображений на наших данных и добиться хорошего качества даже на относительно небольших наборах, как в нашем случае.

Итак, начиная с исходных изображений, уменьшим их до $96\times 96$ пикселей и передадим в блок переноса обучения (Transfer Learning):

Для сравнения оставим размер изображений $96\times 96$. Однако учтите: с Grove Vision AI Module V2 и его внутренней SRAM объёмом 2,4 МБ можно использовать и более крупные изображения (например, $160\times 160$).

Также в правом верхнем углу выберите устройство Target (Himax WiseEye2 (M55 400 MHz + U55)).

Предобработка (генерация признаков)

Помимо изменения размера, изображения можно перевести в оттенки серого или сохранить исходную цветовую глубину RGB. Выберем [RGB] в разделе Image. Тогда каждый образец данных будет иметь размерность 27 648 признаков ($96\times 96\times 3$). Нажатие [Save Parameters] откроет новую вкладку Generate Features. Нажмите кнопку [Generate Features], чтобы сгенерировать признаки.

Проектирование модели, обучение и тестирование

В 2017 году Google представил MobileNetV1. В 2018 году вышла MobileNetV2: Inverted Residuals and Linear Bottlenecks, а в 2019 году — V3. MobileNet — это семейство универсальных нейронных сетей для компьютерного зрения, специально созданных для мобильных устройств и поддерживающих классификацию, обнаружение и другие задачи. MobileNet — компактные модели с малой задержкой и низким энергопотреблением, параметризованные так, чтобы соответствовать ограничениям ресурсов разных сценариев.

Хотя базовая архитектура MobileNet уже компактна и быстра, конкретному сценарию часто нужна модель ещё меньше и быстрее. Для этого в MobileNet есть простой параметр α (альфа), называемый множителем ширины (width multiplier), с помощью которого строятся меньшие и менее требовательные к вычислениям модели. Множитель ширины α равномерно «утончает» сеть на каждом слое.

В Edge Impulse Studio доступны MobileNet V1 (изображения $96\times 96$) и V2 (изображения $96\times 96$ и $160\times 160$) с несколькими значениями α (от 0,05 до 1,0). Например, наибольшая точность достигается у V2 с изображениями $160\times 160$ и α=1,0. Конечно, здесь есть компромисс: чем выше точность, тем больше памяти (примерно 1,3 МБ ОЗУ и 2,6 МБ ПЗУ) нужно для запуска модели и тем выше задержка. Самый маленький объём получится на другом полюсе — у MobileNet V1 с α=0,10 (примерно 53,2 КБ ОЗУ и 101 КБ ПЗУ).

Для сравнения мы возьмём MobileNet V2 0.1 в качестве базовой модели (но можно использовать и модель с большим α). Последний слой модели, перед выходным слоем, будет содержать 8 нейронов с dropout-регуляризацией 10 % для предотвращения переобучения.

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

Задайте гиперпараметры:

• Эпохи (Epochs): 20;
• Размер батча (Batch Size): 32;
• Скорость обучения (Learning Rate): 0,0005;
• Размер валидационной выборки (Validation size): 20 %.

Результат обучения:

Профиль модели предсказывает 146 КБ ОЗУ и 187 КБ флеш-памяти, что не создаёт проблем для Grove Vision AI (V2), у которого почти 2,5 МБ внутренней SRAM. Кроме того, Studio показывает задержку около 4 мс.

Тем не менее, при точности 100 % на валидационной выборке и при тестировании на отложенных данных мы получили точность 81 % для квантованной (Int8) обученной модели. Однако для наших целей этого достаточно.

Развёртывание модели

На вкладке Deployment выберите Seeed Grove Vision AI Module V2 (Himax WiseEye2) и нажмите [Build]. На компьютер загрузится ZIP-файл.

ZIP-архив содержит файл model_vela.tflite — модель TensorFlow Lite (TFLite), оптимизированную для нейронных процессоров (NPU) с помощью компилятора Vela, инструмента от Arm для адаптации моделей TFLite под NPU Ethos-U.

Модель можно прошить, следуя инструкциям в README.txt, или через SenseCraft AI Studio. Мы воспользуемся вторым способом.

Развёртывание модели в SenseCraft AI Studio

В SenseCraft AI Studio перейдите на вкладку Vision Workspace и подключите устройство:

Вы увидите последнюю модель, загруженную на устройство. Нажмите зелёную кнопку [Upload Model]. Во всплывающем окне нужно указать имя модели, файл модели и ввести названия классов (объектов). Используйте метки в алфавитном порядке: 0: background, 1: periquito и 2: robot, затем нажмите [Send].

Через несколько секунд модель будет загружена («прошита») в устройство, а изображение с камеры появится в реальном времени в секции Preview. Результат классификации отображается под предпросмотром изображения. Также можно выбрать порог уверенности инференса (Confidence Threshold), передвинув ползунок в разделе Settings.

В Device Logger можно посмотреть Serial Monitor, где видна задержка: около 1–2 мс на предобработку и 4–5 мс на инференс, что совпадает с оценками в Edge Impulse Studio.

Вот другие снимки экрана:

Энергопотребление этой модели составляет около 70 мА, или 0,4 Вт.

Неофициальный бенчмарк классификации изображений

Для встраиваемого машинного обучения (TinyML) можно использовать несколько отладочных плат. Наиболее распространённые на сегодня для задач компьютерного зрения с низким энергопотреблением — ESP32 CAM, Seeed XIAO ESP32S3 Sense и Arduino Nicla Vision.

Мы воспользовались возможностью и развернули аналогичную модель, обученную похожим образом — MobileNetV2 $96\times 96$ с α=0,1 — также на ESP-CAM, XIAO и Raspberry Pi Zero W2. Вот результат:

Grove Vision AI V2 с ARM Ethos-U55 работает примерно в 14 раз быстрее устройств с ARM-M7 и более чем в 100 раз быстрее Xtensa LX6 (ESP-CAM). Даже по сравнению с Raspberry Pi, у которой гораздо более мощный процессор, U55 почти вдвое снижает задержку. Кроме того, энергопотребление ниже, чем у других устройств (сравнение энергопотребления см. в полной статье).

Постобработка

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

Учтите, что в качестве управляющего контроллера можно использовать любой микроконтроллер, например XIAO, Arduino или Raspberry Pi.

Получение видеопотока

Обработка изображений и инференс модели выполняются локально в Grove Vision AI (V2), а результат мы хотим передать на XIAO (управляющий контроллер) по шине IIC. Для этого используем библиотеку Arduino SSCMA. Её основная задача — обрабатывать поток данных Grove Vision AI, но не сам инференс модели.

Grove Vision AI (V2) передаёт результаты инференса на XIAO по IIC; адрес устройства на шине IIC — 0x62. Передача изображения осуществляется через последовательный порт USB.

Шаг 1. Скачайте библиотеку Arduino SSCMA в виде ZIP-архива с её страницы на GitHub:

Шаг 2. Установите её в Arduino IDE (sketch > Include Library > Add .Zip Library).

Шаг 3. Установите библиотеку ArduinoJSON.

Шаг 4. Установите библиотеку Eigen.

Шаг 5. Теперь подключите XIAO и Grove Vision AI (V2) через разъём (ряд контактов), расположенный на задней стороне устройства.

ВНИМАНИЕ: соблюдайте направление соединения: Type-C разъём Grove Vision AI должен быть направлен в ту же сторону, что и Type-C разъём XIAO.

Шаг 6. Подключите порт XIAO USB-C к компьютеру.

Шаг 7. В Arduino IDE выберите плату XIAO и соответствующий порт USB.

Когда мы захотим передавать видео на веб-страницу, понадобится XIAO ESP32S3: у неё есть Wi-Fi и достаточно памяти для обработки изображений. Выберите XIAO_ESP32S3 и нужный порт USB:

По умолчанию PSRAM отключена. Откройте меню Tools и в пункте PSRAM выберите "OPI PSRAM".

Шаг 8. Откройте пример в Arduino IDE:

File → Examples → Seeed_Arduino_SSCMA → camera_web_server.

Затем измените ssid и password в скетче camera_web_server.ino, чтобы они совпадали с вашей сетью Wi-Fi.

Шаг 9. Загрузите скетч на плату и откройте Serial Monitor. Когда плата подключится к сети Wi-Fi, в мониторе отобразится её IP-адрес.

Откройте этот адрес в веб-браузере. Станет доступно видеоприложение (Video App). Чтобы видеть только видеопоток с Grove Vision AI V2, нажмите [Sample Only] и [Start Stream].

Если хотите создать набор изображений, это приложение можно использовать, сохраняя кадры видео с устройства. Нажмите [Save Frame] — изображение сохранится в папку загрузок на компьютере.

Если открыть приложение без выбора [Sample Only], результат инференса должен появиться на видеоэкране. Для классификации изображений этого не происходит, а вот для обнаружения объектов или оценки позы результат встраивается в видеопоток.

Например, если модель — Person Detection на основе YOLOv8:

Получение результата инференса

• Перейдите в File → Examples → Seeed_Arduino_SSCMA → inference_class.

• Загрузите скетч на плату и откройте Serial Monitor.

• Направьте камеру на один из наших объектов — результат инференса появится в последовательном терминале.

Инференс в Arduino IDE потреблял в среднем 160 мА, или 800 мВт, с пиком 330 мА (1,65 Вт) при передаче изображения в приложение.

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

Идея постобработки такая: когда распознан определённый объект (например, попугайчик — метка 1), пользовательский светодиод включается. Если обнаружены робот или фон, светодиод выключен.

Скопируйте код ниже и вставьте его в IDE:

#include <Seeed_Arduino_SSCMA.h>
SSCMA AI;

void setup()
{
    AI.begin();

    Serial.begin(115200);
    while (!Serial);
    Serial.println("Инференс — Grove AI V2 / XIAO ESP32S3");

    // Пины встроенного светодиода
    pinMode(LED_BUILTIN, OUTPUT);
    // Убедитесь, что светодиод выключен по умолчанию.
    // Примечание: светодиод горит, когда пин в состоянии LOW, и гаснет при HIGH.
    digitalWrite(LED_BUILTIN, HIGH);
}

void loop()
{
    if (!AI.invoke()){
        Serial.println("\nВызов выполнен успешно");
        Serial.print("Задержка [мс]: предобработка=");
        Serial.print(AI.perf().prepocess);
        Serial.print(", инференс=");
        Serial.print(AI.perf().inference);
        Serial.print(", постобработка=");
        Serial.println(AI.perf().postprocess);
        int pred_index = AI.classes()[0].target;
        Serial.print("Результат= метка: ");
        Serial.print(pred_index);
        Serial.print(", оценка=");
        Serial.println(AI.classes()[0].score);
        turn_on_led(pred_index);
    }
}

/**
* @brief      Функция turn_off_led — выключает пользовательский светодиод
*/
void turn_off_led(){
    digitalWrite(LED_BUILTIN, HIGH);
}

/**
* @brief      Функция turn_on_led — включает пользовательский светодиод
* @param[in]  pred_index
*             метка 0: [0] ==> все выключены
*             метка 1: [1] ==> светодиод включён
*             метка 2: [2] ==> все выключены
*             метка 3: [3] ==> все выключены
*/
void turn_on_led(int pred_index) {
    switch (pred_index)
    {
        case 0:
            turn_off_led();
            break;
        case 1:
            turn_off_led();
            digitalWrite(LED_BUILTIN, LOW);
            break;
        case 2:
            turn_off_led();
            break;
        case 3:
            turn_off_led();
            break;
    }
}

Этот скетч использует библиотеку Seeed_Arduino_SSCMA.h для связи с модулем Grove Vision AI Module V2. Модуль ИИ и светодиод инициализируются в функции setup(), и запускается последовательная связь.

Функция loop() многократно вызывает метод invoke(), чтобы выполнить инференс с помощью встроенных алгоритмов модуля Grove Vision AI Module V2. При успешном инференсе скетч выводит в монитор порта метрики производительности: время предобработки, инференса и постобработки.

Скетч обрабатывает и выводит подробную информацию о результатах инференса:

• (AI.classes()[0]) определяет класс изображения (.target) и его оценку уверенности (.score);
• результат инференса (класс) сохраняется в целочисленной переменной pred_index, которая передаётся в функцию turn_on_led(). В результате светодиод включается или выключается в зависимости от результата классификации.

Вот результат:

Если распознан попугайчик (метка 1), светодиод горит:

Если распознан робот (метка 2), светодиод не горит (то же самое для фона, метка 0):

Поэтому теперь мы можем питать Grove Vision AI V2 + XIAO ESP32S3 от внешней батареи, а результат инференса будет отображаться светодиодом полностью офлайн. Потребление составляет примерно 165 мА, или 825 мВт.

Результат также можно передавать по Wi-Fi, BLE или другим протоколам связи, доступным на используемом управляющем устройстве.

Дополнительно: постобработка на внешних устройствах

Одно из важных преимуществ работы с периферийным ИИ (Edge AI) — устройства могут работать полностью без облака, обеспечивая непосредственное взаимодействие с реальным миром. В предыдущем разделе мы делали это со встроенным светодиодом XIAO. Теперь подключим внешние светодиоды (это может быть любое исполнительное устройство).

Светодиоды следует подключать к земле XIAO через резистор 220 Ом.

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

ЦЕЛЬ: при распознавании изображения попугайчика включается зелёный светодиод; если это робот, включается жёлтый светодиод; если это фон, включается красный светодиод.

Обработка изображений и инференс модели выполняются локально в Grove Vision AI (V2), а результат мы хотим передать на XIAO по IIC. Для этого снова используем библиотеку Arduino SSCMA.

Вот скетч, который будем использовать:

#include <Seeed_Arduino_SSCMA.h>
SSCMA AI;

// Определите пины светодиодов согласно схеме выводов
// Отрицательный вывод светодиодов следует подключить к земле XIAO
// через резистор 220 Ом.
int LEDR = D1; // Пин 1 XIAO ESP32S3
int LEDY = D2; // Пин 2 XIAO ESP32S3
int LEDG = D3; // Пин 3 XIAO ESP32S3

void setup()
{
    AI.begin();

    Serial.begin(115200);
    while (!Serial);
    Serial.println("Инференс — Grove AI V2 / XIAO ESP32S3");

// Инициализация внешних светодиодов
    pinMode(LEDR, OUTPUT);
    pinMode(LEDY, OUTPUT);
    pinMode(LEDG, OUTPUT);
    // Убедитесь, что светодиоды выключены по умолчанию.
    // Примечание: светодиоды горят, когда пин в состоянии HIGH, и гаснут при LOW.
    digitalWrite(LEDR, LOW);
    digitalWrite(LEDY, LOW);
    digitalWrite(LEDG, LOW);
}

void loop()
{
    if (!AI.invoke()){
        Serial.println("\nВызов выполнен успешно");
        Serial.print("Задержка [мс]: предобработка=");
        Serial.print(AI.perf().prepocess);
        Serial.print(", инференс=");
        Serial.print(AI.perf().inference);
        Serial.print(", постобработка=");
        Serial.println(AI.perf().postprocess);
        int pred_index = AI.classes()[0].target;
        Serial.print("Результат= метка: ");
        Serial.print(pred_index);
        Serial.print(", оценка=");
        Serial.println(AI.classes()[0].score);
        turn_on_leds(pred_index);
    }
}

/**
* @brief turn_off_leds — выключает все светодиоды
*/
void turn_off_leds(){
    digitalWrite(LEDR, LOW);
    digitalWrite(LEDY, LOW);
    digitalWrite(LEDG, LOW);
}

/**
* @brief turn_on_leds — включает определённый светодиод
* @param[in]  pred_index
*             метка 0: [0] ==> горит красный
*             метка 1: [1] ==> горит зелёный
*             метка 2: [2] ==> горит жёлтый
*/
void turn_on_leds(int pred_index) {
    switch (pred_index)
    {
        case 0:
            turn_off_leds();
            digitalWrite(LEDR, HIGH);
            break;
        case 1:
            turn_off_leds();
            digitalWrite(LEDG, HIGH);
            break;
        case 2:
            turn_off_leds();
            digitalWrite(LEDY, HIGH);
            break;
        case 3:
            turn_off_leds();
            break;
    }
}

Grove Vision AI V2 нужно подключить к XIAO через разъём I2C Grove. Для XIAO мы используем плату расширения (хотя IIC можно подключить и напрямую к контактам XIAO). Питание плат можно подать через разъём USB-C, но можно использовать и батарею.

Вот результат:

Пиковое энергопотребление составило 240 мА (зелёный светодиод), или 1,2 Вт. Питание жёлтого и красного светодиодов потребляет 140 мА, или 0,7 Вт. Вывод информации в терминал через последовательный порт не влияет на энергопотребление.

Итоги

В этой лабораторной работе мы полностью прошли процесс разработки системы классификации изображений на модуле Seeed Studio Grove Vision AI Module V2 с чипом Himax WiseEye2. Мы прошли все этапы рабочего процесса машинного обучения: от определения целей проекта до развёртывания рабочей модели с взаимодействием с реальным миром.

Grove Vision AI V2 показал впечатляющую производительность: время инференса составляет всего 4–5 мс, что намного превосходит другие распространённые платформы TinyML. По результатам нашего бенчмарка он примерно в 14 раз быстрее устройств на ARM-M7 и более чем в 100 раз быстрее Xtensa LX6 (ESP-CAM). Даже по сравнению с Raspberry Pi Zero W2 блок NPU Ethos-U55 обеспечил почти двукратный прирост скорости при меньшем энергопотреблении.

В этом проекте мы увидели, как перенос обучения позволяет получить хорошие результаты классификации на относительно небольшом наборе собственных изображений. Модель MobileNetV2 с α=0,1 обеспечила отличный баланс точности и эффективности для нашей задачи с тремя классами: ей нужно всего 146 КБ ОЗУ и 187 КБ флеш-памяти, что легко укладывается в 2,4 МБ внутренней SRAM модуля Grove Vision AI Module V2.

Мы также рассмотрели несколько вариантов развёртывания: от просмотра результатов инференса в SenseCraft AI Studio до автономной системы с визуальной индикацией на светодиодах. Возможность передавать видео в веб-браузер и обрабатывать результаты инференса локально демонстрирует универсальность систем периферийного ИИ для реальных задач.

Потребление энергии итоговой системы оставалось очень низким — примерно от 70 мА (0,4 Вт) при базовом инференсе до 240 мА (1,2 Вт) при управлении внешними компонентами. Благодаря этой эффективности Grove Vision AI Module V2 — отличный выбор для устройств с батарейным питанием, где энергопотребление критично.

Эта работа показала, что сложные задачи компьютерного зрения теперь можно выполнять полностью на периферии, без облачных сервисов и мощных компьютеров. Благодаря таким инструментам, как Edge Impulse Studio и SenseCraft AI Studio, процесс разработки стал доступен даже тем, у кого нет серьёзного опыта в машинном обучении.

По мере развития технологий периферийного ИИ компактные и энергоэффективные устройства, такие как Grove Vision AI Module V2, будут становиться всё мощнее, открывая новые возможности для умных датчиков, IoT-приложений и встроенного интеллекта в повседневных предметах.

Ресурсы

• Сбор изображений в SenseCraft AI Studio
• Проект в Edge Impulse Studio
• SenseCraft AI Studio — Vision Workplace (развёртывание моделей)
• Другие примеры Himax
• Скетчи для Arduino

Обнаружение объектов

Эта лабораторная работа находится в разработке.

Настройка и приложения без кода

В этой лабораторной работе мы исследуем приложения компьютерного зрения (CV) с помощью модуля Grove Vision AI Module V2 от Seeed Studio — мощного, но компактного устройства, созданного специально для приложений встраиваемого машинного обучения. Модуль построен на микросхеме Himax WiseEye2 и предназначен для работы ИИ на периферийных устройствах, поэтому он идеально подходит для задач периферийного машинного обучения (Edge ML).

Введение

Обзор модуля Grove Vision AI (V2)

Grove Vision AI (V2) — модуль компьютерного зрения на базе микроконтроллера. В нём используется процессор Himax WiseEye2 HX6538 с двухъядерным Arm Cortex-M55 и встроенным блоком нейронных сетей Arm Ethos-U55. Arm Ethos-U55 — это класс процессоров для машинного обучения (ML), созданный специально как микро-NPU для ускорения инференса ML во встраиваемых и IoT-устройствах с ограниченной площадью кристалла. В сочетании с процессором Cortex-M55, рассчитанным на ИИ, Ethos-U55 обеспечивает прирост производительности ML в 480 раз по сравнению с существующими системами на базе Cortex-M. Тактовая частота составляет 400 МГц, а внутренняя системная память (SRAM) конфигурируется и имеет максимальный объём 2,4 МБ.

Примечание: по данным документации Seeed Studio, помимо внутренней памяти Himax объёмом 2,5 МБ (2,4 МБ SRAM и 64 КБ ПЗУ), Grove Vision AI (V2) оснащён внешней флеш-памятью 16 МБ / 133 МГц.

Ниже приведена блок-схема системы Grove Vision AI (V2), включающей камеру и управляющий контроллер.

Благодаря интерфейсам IIC, UART, SPI и Type-C Grove Vision AI (V2) легко подключается к устройствам вроде XIAO, Raspberry Pi, BeagleBoard и плат на базе ESP для дальнейшей разработки. Например, интеграция Grove Vision AI V2 с одним из устройств семейства XIAO упрощает доступ к результатам инференса через Arduino IDE или MicroPython и подключение к облаку или выделенным серверам, например к Home Assistant.

С помощью разъёма I2C Grove Grove Vision AI V2 легко подключается к любому управляющему устройству.

Помимо производительности, стоит отметить энергопотребление. Например, в сравнительном тесте с XIAO ESP32S3 Sense при запуске модели Swift-YOLO Tiny 96×96 Grove Vision AI V2 показал более высокую производительность (30 FPS против 5,5 FPS) и при этом меньшее энергопотребление (0,35 Вт против 0,45 Вт).

Сравнение (и с другими устройствами) можно найти в статье 2024 MCU AI Vision Boards: Performance Comparison — она подтверждает высокую производительность Grove Vision AI (V2).

Установка камеры

Когда Grove Vision AI (V2) и камера готовы, можно подключить, например, модуль Raspberry Pi OV5647 Camera Module через шлейф CSI.

При подключении обратите внимание на направление ряда контактов и убедитесь, что шлейф вставлен правильно, а не в обратную сторону.

SenseCraft AI Studio

SenseCraft AI Studio — надёжная платформа, которая предлагает широкий набор моделей ИИ для разных устройств, включая XIAO ESP32S3 Sense и Grove Vision AI V2. В этой работе мы пройдём процесс использования модели ИИ с Grove Vision AI V2 и посмотрим результат её работы. Также мы разберём ключевые понятия и настройки и научимся оптимизировать производительность модели.

Модели также можно развернуть с помощью SenseCraft Web Toolkit — упрощённой версии SenseCraft AI Studio.

Для простоты можно начать с SenseCraft Web Toolkit, а можно сразу перейти в SenseCraft AI Studio, где больше ресурсов.

SenseCraft Web Toolkit

SenseCraft Web Toolkit — это визуальный инструмент развёртывания моделей, входящий в состав SSCMA (Seeed SenseCraft Model Assistant). Он позволяет просто и быстро развёртывать модели на разных платформах. У инструмента удобный интерфейс, и для работы не нужно писать код.

SenseCraft Web Toolkit основан на Himax AI Web Toolkit, который при желании (необязательно) можно скачать по ссылке. После загрузки и распаковки на локальный компьютер дважды щёлкните index.html, чтобы запустить его локально.

В нашем случае выполним следующие шаги, чтобы запустить SenseCraft-Web-Toolkit:

• Откройте сайт SenseCraft-Web-Toolkit в браузере Chrome.
• Подключите Grove Vision AI (V2) к компьютеру кабелем Type-C.
• Когда Grove Vision AI (V2) подключён, выберите его, как показано ниже:

• Выберите устройство и порт и нажмите [Connect]:

Примечание: инструмент WebUSB может работать некорректно в некоторых браузерах, например в Safari. Используйте Chrome.

Можно попробовать несколько базовых моделей компьютерного зрения, заранее загруженных Seeed Studio. Если навести курсор на модель ИИ, станут видны её название, описание, категория (классификация изображений, обнаружение объектов или детекция позы и ключевых точек), алгоритм (например, YOLO V5 или V8, FOMO, MobileNet V2 и т. д.) и метрики (точность Accuracy или mAP).

Чтобы использовать одну из готовых моделей, нажмите на неё и затем на кнопку [Send], либо загрузите собственную модель.

Для платформы SenseCraft AI следуйте инструкциям по ссылке.

Изучение моделей компьютерного зрения

Обнаружение объектов

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

К архитектурам, которые задали эталон в обнаружении объектов, относятся модели YOLO (You Only Look Once), SSD (Single Shot MultiBox Detector), FOMO (Faster Objects, More Objects) и Faster R-CNN (Region-based Convolutional Neural Networks).

Выберем одну из готовых моделей ИИ, например Person Detection (обнаружение людей), которая обучена с помощью алгоритма Swift-YOLO.

После успешной загрузки модели в области предпросмотра справа появится видеопоток с камеры Grove Vision AI (V2). Подробности инференса можно вывести в Serial Monitor, нажав кнопку [Device Log] вверху.

В SenseCraft AI Studio журнал устройства (Device Logger) всегда отображается на экране.

Я направил камеру на себя, поэтому модель нашла только одного человека и выдала одну рамку (box). Если присмотреться, модуль непрерывно передаёт две строки данных:

perf (производительность) — задержки в миллисекундах:

• время предобработки (захват изображения и обрезка): 7 мс;
• время инференса (задержка модели): 76 мс (13 fps);
• время постобработки (вывод изображения и добавление данных): меньше 1 мс (в журнале — 0 мс).

boxes — объекты, найденные на изображении. В данном случае — один.

• У рамки координаты x, y, w и h равны (245, 292, 449, 392), а объект (человек, метка 0) распознан с уверенностью 0,89.

Если направить камеру на изображение с несколькими людьми, для каждого человека (объекта) будет своя рамка:

В SenseCraft AI Studio задержка инференса (48 мс) меньше, чем в SenseCraft ToolKit (76 мс), благодаря другой реализации развёртывания.

Энергопотребление

Пиковое энергопотребление при работе этой модели Swift-YOLO составило 410 милливатт.

Настройки предпросмотра

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

• Confidence (уверенность): уровень достоверности, который модель присваивает своим предсказаниям. Этот параметр задаёт минимальный уровень уверенности, при котором детекция считается верной. При более высоком пороге детекций будет меньше, но они будут надёжнее; при более низком — детекций будет больше, однако среди них могут оказаться ложные срабатывания.

• IoU: метрика, которая оценивает точность предсказанных ограничивающих рамок по сравнению с эталонными (ground truth). IoU измеряет степень перекрытия предсказанной рамки и эталонной и используется для оценки точности обнаружения объектов. Порог IoU задаёт минимальное значение, при котором детекция считается истинно положительной. Изменение этого порога помогает тонко настроить точность (precision) и полноту (recall) модели.

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

Детекция позы и ключевых точек

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

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

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

Остановите текущий инференс кнопкой [Stop] в области предпросмотра. Выберите модель и нажмите [Send]. После успешной загрузки модели вы увидите видеопоток с камеры Grove Vision AI (V2) в области предпросмотра справа и данные инференса в Serial Monitor (кнопка [Device Log] вверху).

Модель YOLOv8 Pose обучена на наборе данных COCO-Pose, который содержит 200 тысяч изображений с разметкой из 17 ключевых точек для задач оценки позы.

Рассмотрим один кадр инференса (для простоты возьмём изображение с одним человеком). Видны две строки: одна — с производительностью инференса в миллисекундах (121 мс), вторая — с ключевыми точками:

• 1 блок информации, такой же, как в примере с обнаружением объектов: координаты рамки (113, 119, 67, 208), результат инференса (90) и метка (0);
• 17 групп по 4 числа — это 17 «суставов» тела, где «0» — нос, «1» и «2» — глаза, «15» и «16» — стопы и так далее.

Чтобы глубже разобраться в проекте оценки позы, см. руководство Exploring AI at the Edge! — Pose Estimation.

Классификация изображений

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

Классификация изображений важна во многих приложениях — от организации и поиска в больших базах изображений в цифровых библиотеках и соцсетях до помощи автономным системам в понимании окружающего мира. Среди архитектур, которые заметно продвинули классификацию изображений, — свёрточные нейронные сети (CNN), например AlexNet, VGGNet и ResNet. Эти модели показали высокую точность на сложных наборах данных, таких как ImageNet, обучаясь иерархическим представлениям визуальных данных.

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

Этот пример доступен в SenseCraft ToolKit, но не в SenseCraft AI Studio. В последнем можно найти и другие примеры классификации изображений.

После успешной загрузки модели можно посмотреть видеопоток с камеры Grove Vision AI (V2) в области предпросмотра справа и данные инференса в Serial Monitor (кнопка [Device Log] вверху).

В результате мы получаем оценку и класс.

Например, [99, 1] означает класс 1 (человек) с оценкой 0,99. Поскольку эта модель бинарная, класс 0 будет «Нет человека» (или фон). Задержка инференса — 15 мс, то есть около 70 кадров в секунду.

Энергопотребление

Для запуска MobileNet V2 0.35 Grove Vision AI V2 потреблял пиковый ток 80 мА при напряжении 5,24 В, что соответствует энергопотреблению 420 мВт.

При запуске той же модели на XIAO ESP32S3 Sense энергопотребление составило 523 мВт при задержке 291 мс.

Другие модели в SenseCraft AI Studio

Несколько публичных моделей ИИ можно скачать на веб-странице SenseCraft AI. Например, можно запустить модель Swift-YOLO, распознающую светофоры, как показано ниже:

Задержка этой модели составляет около 86 мс, среднее энергопотребление — 420 мВт.

Проект классификации изображений

Создадим полноценный проект классификации изображений в SenseCraft AI Studio.

В SenseCraft AI Studio откройте вкладку Training:

По умолчанию обучается модель Classification с веб-камерой, если она доступна. Выберем вместо неё Grove Vision AI V2. Нажмите зелёную кнопку [Connect] — появится всплывающее окно. Выберите нужный порт и нажмите синюю кнопку [Connect].

На экране появится изображение, которое передаёт Grove Vision AI V2.

Цель

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

Сбор данных

Создадим классы, например, в алфавитном порядке:

• Класс 1: background (фон)
• Класс 2: box (коробка)
• Класс 3: wheel (колесо)

Выберите один из классов и удерживайте зелёную кнопку под областью предпросмотра. Собранные изображения появятся на экране выборки (Image Samples).

После сбора изображений просмотрите их и удалите некорректные.

Соберите примерно по 50 изображений для каждого класса и перейдите к этапу обучения.

Обучение

Убедитесь, что выбрано правильное устройство (Grove Vision AI V2), и нажмите [Start Training].

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

После обучения можно посмотреть результат инференса.

Обратите внимание: модель при этом не работает на самом устройстве. Устройство только захватывает изображения, а предпросмотр выполняет обучаемая модель, которая запущена в Studio.

Теперь пора по-настоящему развернуть модель на устройстве.

Развёртывание

Выберите обученную модель и нажмите [Deploy to device], затем выберите Grove Vision AI V2:

Studio перенаправит нас на вкладку Vision Workplace. Подтвердите развёртывание, выберите подходящий порт и подключитесь к нему:

Модель будет записана («прошита») в устройство. После автоматической перезагрузки модель начнёт работать на устройстве. В журнале устройства (Device Logger) видно, что задержка инференса составляет около 8 мс, что соответствует частоте кадров 125 кадров в секунду (FPS).

Также можно настроить уверенность модели (confidence).

Для работы модели классификации изображений Grove Vision AI V2 потреблял пиковый ток 80 мА при 5,24 В, что соответствует энергопотреблению 420 мВт.

Сохранение модели

Модель можно сохранить в SenseCraft AI Studio. Studio хранит все наши модели, и их можно развернуть позже. Для этого вернитесь на вкладку Training и нажмите кнопку [Save to SenseCraft]:

Итоги

В этой лабораторной работе мы исследовали несколько приложений компьютерного зрения (CV) с помощью модуля Seeed Studio Grove Vision AI Module V2. Модуль показал себя как мощное, но компактное устройство, созданное специально для приложений встраиваемого машинного обучения.

Производительность. Grove Vision AI V2 показал отличные результаты в нескольких задачах компьютерного зрения. Благодаря чипу Himax WiseEye2 с двухъядерным Arm Cortex-M55 и встроенным блоком нейронных сетей Arm Ethos-U55 устройство обеспечило:

• Классификация изображений: время инференса 15 мс (67 FPS);
• Обнаружение объектов (человек): время инференса от 48 до 76 мс (от 21 до 13 FPS);
• Детекция позы: 121 мс на обнаружение ключевых точек в реальном времени с отслеживанием 17 суставов (8 FPS).

Лидерство в энергоэффективности. Одно из самых убедительных преимуществ Grove Vision AI V2 — высокая энергоэффективность. Сравнительные тесты показали заметное превосходство над традиционными встраиваемыми платформами:

• Grove Vision AI V2: пиковое потребление 80 мА (410 мВт) при более чем 60 FPS;
• XIAO ESP32S3: при похожей задаче классификации изображений — 523 мВт при более чем 3 FPS.

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

Удобная экосистема для разработчиков. SenseCraft AI Studio с возможностями развёртывания без кода и интеграции в пользовательские приложения делает Grove Vision AI V2 доступным как новичкам, так и опытным разработчикам. Обширная библиотека предобученных моделей и поддержка собственных моделей обеспечивают гибкость для разных приложений.

Grove Vision AI V2 — заметный шаг вперёд в аппаратном обеспечении периферийного ИИ: он предлагает профессиональные возможности компьютерного зрения в компактном энергоэффективном корпусе, который делает развёртывание ИИ во встраиваемых приложениях доступным в промышленности, IoT и образовании.

Главные выводы

Эта лабораторная работа показывает, что сложные приложения компьютерного зрения не ограничены облачными решениями или энергоёмким оборудованием, таким как Raspberry Pi или Jetson Nano: сегодня их можно эффективно развернуть на периферии с впечатляющими эффективностью и производительностью.

При желании можно использовать XIAO Vision AI Camera. Это решение объединяет модуль Grove Vision AI V2, контроллер XIAO ESP32-C3 и камеру OV5647 в корпусе, напечатанном на 3D-принтере:

Ресурсы

• Инструкции SenseCraft AI Studio
• Сайт SenseCraft-Web-Toolkit
• SenseCraft AI Studio
• Himax AI Web Toolkit
• Примеры Himax

Обзор

Эти лабораторные работы дают бесценный практический опыт работы с системами машинного обучения на основе Raspberry Pi — гибкой и доступной платформы. В отличие от работы с крупномасштабными моделями, которым нужны обширные облачные ресурсы, эти упражнения позволяют напрямую работать с оборудованием и программным обеспечением в компактной, но мощной среде периферийных вычислений. Вы получите практическое представление о развёртывании ИИ на периферии, используя возможности Raspberry Pi: от экономичной Pi Zero до более мощных моделей Pi 4 и Pi 5. Такой подход даёт осязаемое понимание проблем и возможностей внедрения решений машинного обучения в условиях ограниченных ресурсов. Хотя мы работаем в меньшем масштабе, принципы и методы, которые вы освоите, принципиально похожи на те, что используются в более крупных системах. Способность Raspberry Pi запускать полноценную операционную систему и широкие возможности GPIO создают богатый учебный опыт, который соединяет теоретические знания с реальными приложениями. В ходе этих работ вы разберётесь в тонкостях EdgeML и приобретёте навыки, применимые к широкому спектру сценариев развёртывания ИИ.

Где купить

Платы Raspberry Pi доступны у официальных продавцов по всему миру:

• Продукция Raspberry Pi (официальный сайт с поиском продавцов);
• Raspberry Pi Zero 2 W: ~$15;
• Raspberry Pi 4 (4 ГБ): ~$55;
• Raspberry Pi 5 (4 ГБ): ~$60;
• Raspberry Pi 5 (8 ГБ): ~$80.

Модули камер, блоки питания и SD-карты доступны у тех же продавцов.

Предварительные требования

• Raspberry Pi: убедитесь, что у вас есть хотя бы одна из плат: Raspberry Pi Zero 2 W, Raspberry Pi 4 или 5 для лабораторных работ по зрению и Raspberry Pi 5 для лабораторных работ по генеративному ИИ.

• Блок питания: для питания плат.

  • Raspberry Pi Zero 2 W: 5 В / 2,5 А через адаптер micro-USB;
  • Raspberry Pi 4: 5 В / 3 А через адаптер USB-C;
  • Raspberry Pi 5: 5 В / 5 А через адаптер USB-C.

• Сеть: доступ в интернет для загрузки необходимого программного обеспечения и удалённого управления платами.

• SD-карта (не менее 32 ГБ) и переходник для SD-карты: для операционной системы Raspberry Pi OS.

Настройка

• Настройка Raspberry Pi

Упражнения

Классификация изображений

Промпт DALL·E: обложка для главы «Классификация изображений» руководства по Raspberry Pi, выполненная в том же винтажном стиле лаборатории электроники 1950-х, что и предыдущие обложки. На сцене — Raspberry Pi, подключённая к модулю камеры, которая снимает фотографию маленького синего робота, предоставленного пользователем. Робот стоит на верстаке, вокруг — классические лабораторные инструменты: паяльники, резисторы и провода. На фоне — старинное оборудование: осциллографы и ламповые радиоприёмники, сохраняющие детальное и ностальгическое ощущение эпохи. Логотипов и текста быть не должно.

Обзор

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

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

Применение в реальных сценариях

Классификация изображений нашла применение во многих реальных областях и меняет целые сектора:

• Здравоохранение: помощь в анализе медицинских изображений, например в выявлении отклонений на рентгеновских снимках или МРТ.
• Сельское хозяйство: контроль состояния посевов и выявление болезней растений по снимкам с воздуха.
• Автомобилестроение: системы помощи водителю и беспилотные автомобили распознают дорожные знаки, пешеходов и другие автомобили.
• Розничная торговля: визуальный поиск товаров и автоматизированное управление складскими запасами.
• Безопасность и наблюдение: повышение эффективности обнаружения угроз и систем распознавания лиц.
• Мониторинг окружающей среды: анализ спутниковых снимков для изучения вырубки лесов, городского планирования и исследований изменения климата.

Преимущества классификации на периферийных устройствах, таких как Raspberry Pi

Реализация классификации изображений на периферийных устройствах, таких как Raspberry Pi, даёт несколько весомых преимуществ:

1. Низкая задержка. Локальная обработка изображений исключает передачу данных на облачные серверы и существенно сокращает время отклика.

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

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

4. Экономичность. Не нужны дорогие облачные вычислительные ресурсы, особенно для непрерывной или большой по объёму классификации.

5. Масштабируемость. Возможны распределённые архитектуры, в которых несколько устройств работают независимо или в составе сети.

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

7. Настраиваемость. Развёртывать специализированные или часто обновляемые модели, подогнанные под конкретные задачи, проще.

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

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

Настройка окружения

Обновление Raspberry Pi

Сначала убедитесь, что Raspberry Pi обновлён:

sudo apt update
sudo apt upgrade -y

Установка необходимых библиотек

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

sudo apt install python3-pip
sudo rm /usr/lib/python3.11/EXTERNALLY-MANAGED
pip3 install --upgrade pip

Настройка виртуального окружения (необязательно, но рекомендуется)

Создайте виртуальное окружение для управления зависимостями:

python3 -m venv ~/tflite
source ~/tflite/bin/activate

Установка TensorFlow Lite

Нас интересует инференс — выполнение модели TensorFlow Lite на устройстве для получения предсказаний по входным данным. Чтобы выполнить инференс с моделью TensorFlow Lite, её нужно запустить через интерпретатор. Интерпретатор TensorFlow Lite спроектирован лёгким и быстрым. Он использует статический порядок вычислений графа и собственный (менее динамичный) распределитель памяти, чтобы минимизировать задержки загрузки, инициализации и выполнения.

Мы будем использовать среду выполнения TensorFlow Lite для Raspberry Pi — упрощённую библиотеку для запуска моделей машинного обучения на мобильных и встраиваемых устройствах без установки всех пакетов TensorFlow.

pip install tflite_runtime --no-deps

Установлено колесо (wheel): tflite_runtime-2.14.0-cp311-cp311-manylinux_2_34_aarch64.whl

Установка дополнительных библиотек Python

Установите библиотеки Python, необходимые для классификации изображений:

Если у вас установлена другая версия NumPy, сначала удалите её.

pip3 uninstall numpy

Установите версию 1.23.2, которая совместима с tflite_runtime.

 pip3 install numpy==1.23.2

pip3 install Pillow matplotlib

Создание рабочего каталога

Если вы работаете на Raspi-Zero с минимальной ОС (без рабочего стола), у вас может не быть заранее созданной структуры каталогов пользователя (проверить её можно командой ls). Поэтому создадим её:

mkdir Documents
cd Documents/
mkdir TFLITE
cd TFLITE/
mkdir IMG_CLASS
cd IMG_CLASS
mkdir models
cd models

На Raspi-5 каталог /Documents должен уже существовать.

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

Подходящая предобученная модель — ключ к успешной классификации изображений на устройствах с ограниченными ресурсами, таких как Raspberry Pi. MobileNet создана для мобильного и встраиваемого зрения и хорошо балансирует точность и скорость. Существуют версии MobileNetV1, MobileNetV2 и MobileNetV3. Загрузим версию V2:

# Одна длинная строка, разбитая обратным слешем \
wget https://storage.googleapis.com/download.tensorflow.org/\
models/tflite_11_05_08/mobilenet_v2_1.0_224_quant.tgz

tar xzf mobilenet_v2_1.0_224_quant.tgz

Получите также её метки классов:

wget https://raw.githubusercontent.com/Mjrovai/EdgeML-with-Raspberry-Pi/refs/heads/\
main/IMG_CLASS/models/labels.txt

В итоге в каталоге с моделями должны появиться файлы:

Нам понадобятся только файл mobilenet_v2_1.0_224_quant.tflite и labels.txt. Остальные файлы можно удалить.

Настройка Jupyter Notebook (необязательно)

Если вы предпочитаете разрабатывать в Jupyter Notebook:

pip3 install jupyter
jupyter notebook --generate-config

Чтобы запустить Jupyter Notebook, выполните команду (замените IP-адрес на свой):

jupyter notebook --ip=192.168.4.210 --no-browser

В терминале появится локальный URL-адрес, по которому можно открыть блокнот:

К нему можно обратиться с другого устройства, введя в веб-браузере IP-адрес Raspberry Pi и токен из терминала (токен можно скопировать из терминала).

Определите рабочий каталог на Raspi и создайте новый блокнот Python 3.

Проверка установки

Проверьте установку, запустив простой скрипт Python:

import tflite_runtime.interpreter as tflite
import numpy as np
from PIL import Image

print("NumPy:", np.__version__)
print("Pillow:", Image.__version__)

# Пробуем создать интерпретатор TFLite
model_path = "./models/mobilenet_v2_1.0_224_quant.tflite"
interpreter = tflite.Interpreter(model_path=model_path)
interpreter.allocate_tensors()
print("TFLite Interpreter created successfully!")

Скрипт можно создать в nano прямо в терминале и сохранить комбинацией CTRL+O, ENTER, затем CTRL+X:

И запустить командой:

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

Инференс с MobileNet V2

В предыдущем разделе мы настроили окружение, в том числе загрузили популярную предобученную модель MobileNet V2. Она обучена на изображениях ImageNet размером $224\times 224$ (1,2 миллиона) для 1 001 класса (1 000 категорий объектов и 1 фоновый класс). Модель преобразована в компактный формат TensorFlow Lite размером 3,5 МБ, что делает её подходящей для Raspberry Pi с её ограниченными объёмами памяти и накопителя.

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

Импортируйте нужные библиотеки:

import time
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import tflite_runtime.interpreter as tflite

Загрузите модель TFLite и выделите тензоры:

model_path = "./models/mobilenet_v2_1.0_224_quant.tflite"
interpreter = tflite.Interpreter(model_path=model_path)
interpreter.allocate_tensors()

Получите входные и выходные тензоры.

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

Входные данные (input details) сообщают, как модели нужно подавать изображение. Форма (1, 224, 224, 3) означает, что изображение размером $(224\times 224\times 3)$ подаётся по одному (размерность батча: 1).

Выходные данные (output details) показывают, что инференс даст массив из 1 001 целого значения. Каждое значение — вероятность того, что соответствующая метка относится к изображению.

Проверим тип данных (dtype) входных данных модели:

input_dtype = input_details[0]["dtype"]
input_dtype

dtype('uint8')

Это означает, что на вход должны подаваться сырые пиксели (0–255).

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

mkdir images
cd images
wget https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg

Загрузим и выведем изображение:

# Загружаем изображение
img_path = "./images/Cat03.jpg"
img = Image.open(img_path)

# Выводим изображение
plt.figure(figsize=(8, 8))
plt.imshow(img)
plt.title("Original Image")
plt.show()

Размер изображения можно узнать командой:

width, height = img.size

Видно, что это RGB-изображение шириной 1600 и высотой 1600 пикселей. Чтобы использовать модель, его нужно привести к размеру (224, 224, 3) и добавить размерность батча 1, как указано во входных данных: (1, 224, 224, 3). Результатом инференса, как показано в выходных данных, будет массив размером 1001, как видно ниже:

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

img = img.resize(
    (input_details[0]["shape"][1], input_details[0]["shape"][2])
)
input_data = np.expand_dims(img, axis=0)
input_data.shape

Форма input_data соответствует ожидаемой: (1, 224, 224, 3).

Проверим тип данных входного массива:

input_data.dtype

dtype('uint8')

Тип данных uint8 совпадает с типом, который ожидает модель.

Используем input_data, запустим интерпретатор и получим предсказания (выход):

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()
predictions = interpreter.get_tensor(output_details[0]["index"])[0]

Предсказание — это массив из 1001 элемента. Получим Top-5 индексов с наибольшими значениями:

top_k_results = 5
top_k_indices = np.argsort(predictions)[::-1][:top_k_results]
top_k_indices

top_k_indices — массив из 5 элементов: array([283, 286, 282, 288, 479])

Итак, 283, 286, 282, 288 и 479 — наиболее вероятные классы изображения. Зная индекс, нужно понять, какому классу он соответствует (например, автомобиль, кошка или собака). Текстовый файл, загруженный вместе с моделью, содержит метку для каждого индекса от 0 до 1000. Используем функцию, чтобы загрузить .txt-файл как список:

def load_labels(filename):
    with open(filename, "r") as f:
        return [line.strip() for line in f.readlines()]

Получим список и выведем метки, соответствующие индексам:

labels_path = "./models/labels.txt"
labels = load_labels(labels_path)

print(labels[286])
print(labels[283])
print(labels[282])
print(labels[288])
print(labels[479])

В результате получаем:

Egyptian cat
tiger cat
tabby
lynx
carton

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

scale, zero_point = output_details[0]["quantization"]
dequantized_output = (
    predictions.astype(np.float32) - zero_point
) * scale
exp_output = np.exp(dequantized_output - np.max(dequantized_output))
probabilities = exp_output / np.sum(exp_output)

Выведем вероятности для топ-5:

print(probabilities[286])
print(probabilities[283])
print(probabilities[282])
print(probabilities[288])
print(probabilities[479])

0.27741462
0.3732285
0.16919471
0.10319158
0.023410844

Для наглядности создадим функцию, которая сопоставляет метки с вероятностями:

for i in range(top_k_results):
    print(
        "\t{:20}: {}%".format(
            labels[top_k_indices[i]],
            (int(probabilities[top_k_indices[i]] * 100)),
        )
    )

tiger cat           : 37%
Egyptian cat        : 27%
tabby               : 16%
lynx                : 10%
carton              : 2%

Определение общей функции классификации изображений

Создадим общую функцию: на вход подаётся изображение, на выходе получаем Top-5 возможных классов:

def image_classification(
    img_path, model_path, labels, top_k_results=5
):
    # Загружаем изображение
    img = Image.open(img_path)
    plt.figure(figsize=(4, 4))
    plt.imshow(img)
    plt.axis("off")

    # Загружаем модель TFLite
    interpreter = tflite.Interpreter(model_path=model_path)
    interpreter.allocate_tensors()

    # Получаем входные и выходные тензоры
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    # Предобработка
    img = img.resize(
        (input_details[0]["shape"][1], input_details[0]["shape"][2])
    )
    input_data = np.expand_dims(img, axis=0)

    # Инференс на Raspi-Zero
    interpreter.set_tensor(input_details[0]["index"], input_data)
    interpreter.invoke()

    # Получаем результаты и сопоставляем их с классами
    predictions = interpreter.get_tensor(output_details[0]["index"])[
        0
    ]

    # Получаем индексы top-k результатов
    top_k_indices = np.argsort(predictions)[::-1][:top_k_results]

    # Получаем параметры квантования
    scale, zero_point = output_details[0]["quantization"]

    # Деквантуем выход и применяем softmax
    dequantized_output = (
        predictions.astype(np.float32) - zero_point
    ) * scale
    exp_output = np.exp(
        dequantized_output - np.max(dequantized_output)
    )
    probabilities = exp_output / np.sum(exp_output)

    print("\n\t[PREDICTION]        [Prob]\n")
    for i in range(top_k_results):
        print(
            "\t{:20}: {}%".format(
                labels[top_k_indices[i]],
                (int(probabilities[top_k_indices[i]] * 100)),
            )
        )

Загрузив несколько изображений для проверки, получим:

Тестирование модели, обученной с нуля

Получим модель TFLite, обученную с нуля. Для этого следуйте блокноту:

CNN для классификации набора данных Cifar-10

В блокноте мы обучили модель на наборе данных CIFAR-10, который содержит 60 000 изображений 10 классов CIFAR (самолёт, автомобиль, птица, кошка, олень, собака, лягушка, лошадь, корабль и грузовик). Изображения CIFAR — цветные, размером $32\times 32$ (3 цветовых канала). Объекты на них не центрированы и могут находиться на фоне: например, самолёты могут быть на фоне облачного неба! Короче говоря, это маленькие, но настоящие изображения.

Обученная CNN-модель (cifar10_model.keras) занимала 2,0 МБ. С помощью TFLite Converter модель cifar10.tflite уменьшилась до 674 КБ (около трети исходного размера).

В блокноте Cifar 10 — классификация изображений на Raspi с TFLite, который можно запустить на Raspi, мы повторим те же шаги, что и с mobilenet_v2_1.0_224_quant.tflite. Ниже приведены примеры классификации изображений с помощью общей функции классификации на Raspi-Zero, как в предыдущем разделе.

Установка Picamera2

Picamera2 — библиотека Python для работы с камерой Raspberry Pi. Она основана на стеке камер libcamera и поддерживается фондом Raspberry Pi. Picamera2 работает на всех моделях Raspberry Pi — от Pi Zero до RPi 5. На Raspi она уже установлена в системе, но её нужно сделать доступной внутри виртуального окружения.

1. Сначала активируйте виртуальное окружение, если оно ещё не активировано:

   source ~/tflite/bin/activate
   

2. Теперь создайте файл .pth в виртуальном окружении, чтобы добавить путь к системным site-packages:

   echo "/usr/lib/python3/dist-packages" > \
     $VIRTUAL_ENV/lib/python3.11/site-packages/system_site_packages.pth
   

   Примечание: если у вас другая версия Python, замените python3.11 на нужную версию.

3. После создания файла попробуйте импортировать picamera2 в Python:

   python3
   >>> import picamera2
   >>> print(picamera2.__file__)
   

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

/home/username/tflite/lib/python3.11/site-packages/\
picamera2/__init__.py

Также можно вывести список доступных в системе камер:

>>> print(Picamera2.global_camera_info())

В моём случае, с подключённой USB-камерой, получилось:

Теперь, когда мы убедились, что picamera2 работает в окружении с index 0, попробуем простой скрипт Python, который захватывает изображение с USB-камеры:

from picamera2 import Picamera2
import time

# Инициализируем камеру
picam2 = Picamera2()  # по умолчанию индекс 0

# Настраиваем камеру
config = picam2.create_still_configuration(main={"size": (640, 480)})
picam2.configure(config)

# Запускаем камеру
picam2.start()

# Даём камере прогреться
time.sleep(2)

# Делаем снимок
picam2.capture_file("usb_camera_image.jpg")
print("Image captured and saved as 'usb_camera_image.jpg'")

# Останавливаем камеру
picam2.stop()

Используйте редактор Nano, Jupyter Notebook или любой другой редактор. Сохраните код как Python-скрипт (например, capture_image.py) и запустите его. Скрипт захватит изображение с камеры и сохранит его как «usb_camera_image.jpg» в том же каталоге, где находится скрипт.

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

Если вы работаете с Raspi-5 и у вас полноценный рабочий стол, можно открыть файл прямо на устройстве.

Проект классификации изображений

Теперь разработаем полноценный проект классификации изображений с использованием Edge Impulse Studio. Как и в случае с MobileNet V2, для инференса будет использоваться обученная и сконвертированная модель TFLite.

Цель

Первый шаг в любом проекте машинного обучения — определить цель. В данном случае нужно обнаружить и классифицировать два конкретных объекта на одном изображении. Для проекта мы возьмём две небольшие игрушки: робота и маленького бразильского попугая (по имени Periquito). Также соберём изображения фона, на котором этих двух объектов нет.

Сбор данных

Определив цель проекта машинного обучения, мы переходим к следующему, самому важному шагу — сбору набора данных. Снимки можно делать с телефона, но здесь мы будем использовать Raspi. Настроим простой веб-сервер на Raspberry Pi, чтобы просматривать в браузере снимки в формате QVGA (320 x 240).

1. Сначала установите Flask, лёгкий веб-фреймворк для Python:

   pip3 install flask
   

2. Создадим новый скрипт Python, который объединяет захват изображений и веб-сервер. Назовём его get_img_data.py:

from flask import (Flask, Response, render_template_string,
                   request, redirect, url_for)
from picamera2 import Picamera2
import io
import threading
import time
import os
import signal

app = Flask(__name__)

# Глобальные переменные
base_dir = "dataset"
picam2 = None
frame = None
frame_lock = threading.Lock()
capture_counts = {}
current_label = None
shutdown_event = threading.Event()

def initialize_camera():
    global picam2
    picam2 = Picamera2()
    config = picam2.create_preview_configuration(
             main={"size": (320, 240)}
    )
    picam2.configure(config)
    picam2.start()
    time.sleep(2)  # Ждём, пока камера прогреется

def get_frame():
    global frame
    while not shutdown_event.is_set():
        stream = io.BytesIO()
        picam2.capture_file(stream, format='jpeg')
        with frame_lock:
            frame = stream.getvalue()
        time.sleep(0.1)  # При необходимости измените для плавного предпросмотра

def generate_frames():
    while not shutdown_event.is_set():
        with frame_lock:
            if frame is not None:
                yield (b'--frame\r\n'
                       b'Content-Type: image/jpeg\r\n\r\n' +
                                       frame + b'\r\n')
        time.sleep(0.1)  # При необходимости измените для плавной передачи видео

def shutdown_server():
    shutdown_event.set()
    if picam2:
        picam2.stop()
    # Даём время остальным потокам завершиться
    time.sleep(2)
    # Отправляем SIGINT основному процессу
    os.kill(os.getpid(), signal.SIGINT)

@app.route('/', methods=['GET', 'POST'])
def index():
    global current_label
    if request.method == 'POST':
        current_label = request.form['label']
        if current_label not in capture_counts:
            capture_counts[current_label] = 0
        os.makedirs(os.path.join(base_dir, current_label),
                                 exist_ok=True)
        return redirect(url_for('capture_page'))
    return render_template_string('''
        <!DOCTYPE html>
        <html>
        <head>
            <title>Dataset Capture - Label Entry</title>
        </head>
        <body>
            <h1>Enter Label for Dataset</h1>
            <form method="post">
                <input type="text" name="label" required>
                <input type="submit" value="Start Capture">
            </form>
        </body>
        </html>
    ''')

@app.route('/capture')
def capture_page():
    return render_template_string('''
        <!DOCTYPE html>
        <html>
        <head>
            <title>Dataset Capture</title>
            <script>
                var shutdownInitiated = false;
                function checkShutdown() {
                    if (!shutdownInitiated) {
                        fetch('/check_shutdown')
                            .then(response => response.json())
                            .then(data => {
                                if (data.shutdown) {
                                    shutdownInitiated = true;
                                    document.getElementById(
                                          'video-feed').src = '';
                                    document.getElementById(
                                          'shutdown-message')
                                    .style.display = 'block';
                                }
                            });
                    }
                }
                setInterval(checkShutdown, 1000); // Проверка каждую секунду
            </script>
        </head>
        <body>
            <h1>Dataset Capture</h1>
            <p>Current Label: {{ label }}</p>
            <p>Images captured for this label: {{ capture_count
                                                  }}</p>
            <img id="video-feed" src="{{ url_for('video_feed')
                                         }}" width="640"
            height="480" />
            <div id="shutdown-message" style="display: none;
                                              color: red;">
                Capture process has been stopped.
                You can close this window.
            </div>
            <form action="/capture_image" method="post">
                <input type="submit" value="Capture Image">
            </form>
            <form action="/stop" method="post">
                <input type="submit" value="Stop Capture"
                style="background-color: #ff6666;">
            </form>
            <form action="/" method="get">
                <input type="submit" value="Change Label"
                style="background-color: #ffff66;">
            </form>
        </body>
        </html>
    ''', label=current_label, capture_count=capture_counts.get(
                                            current_label, 0))

@app.route('/video_feed')
def video_feed():
    return Response(generate_frames(),
                    mimetype='multipart/x-mixed-replace; boundary=frame')

@app.route('/capture_image', methods=['POST'])
def capture_image():
    global capture_counts
    if current_label and not shutdown_event.is_set():
        capture_counts[current_label] += 1
        timestamp = time.strftime("%Y%m%d-%H%M%S")
        filename = f"image_{timestamp}.jpg"
        full_path = os.path.join(base_dir, current_label,
                                 filename)

        picam2.capture_file(full_path)

    return redirect(url_for('capture_page'))

@app.route('/stop', methods=['POST'])
def stop():
    summary = render_template_string('''
        <!DOCTYPE html>
        <html>
        <head>
            <title>Dataset Capture - Stopped</title>
        </head>
        <body>
            <h1>Dataset Capture Stopped</h1>
            <p>The capture process has been stopped.
               You can close this window.</p>
            <p>Summary of captures:</p>
            <ul>
            {% for label, count in capture_counts.items() %}
                <li>{{ label }}: {{ count }} images</li>
            {% endfor %}
            </ul>
        </body>
        </html>
    ''', capture_counts=capture_counts)

    # Запускаем новый поток для остановки сервера
    threading.Thread(target=shutdown_server).start()

    return summary

@app.route('/check_shutdown')
def check_shutdown():
    return {'shutdown': shutdown_event.is_set()}

if __name__ == '__main__':
    initialize_camera()
    threading.Thread(target=get_frame, daemon=True).start()
    app.run(host='0.0.0.0', port=5000, threaded=True)

3. Запустите скрипт:

python3 get_img_data.py

4. Откройте веб-интерфейс:

   • На самой Raspberry Pi (если есть графический интерфейс): откройте веб-браузер и перейдите по адресу http://localhost:5000.
   • С другого устройства в той же сети: откройте веб-браузер и перейдите по адресу http://<raspberry_pi_ip>:5000 (замените <raspberry_pi_ip> на IP-адрес вашей Raspberry Pi). Например: http://192.168.4.210:5000/

Этот скрипт Python создаёт веб-интерфейс для захвата и организации наборов изображений с помощью Raspberry Pi и её камеры. Он удобен для проектов машинного обучения, которым нужны размеченные изображения.

Основные возможности

1. Веб-интерфейс: доступ с любого устройства в той же сети, что и Raspberry Pi.
2. Живой предпросмотр с камеры: показывает видео с камеры в реальном времени.
3. Система меток: позволяет вводить метки для разных категорий изображений.
4. Организованное хранение: автоматически сохраняет изображения в подкаталогах по меткам.
5. Счётчики по меткам: ведут учёт количества снимков для каждой метки.
6. Итоговая статистика: выводит сводку по снимкам при остановке захвата.

Основные компоненты

1. Веб-приложение Flask: обрабатывает маршруты и отдаёт веб-интерфейс.
2. Интеграция с Picamera2: управляет камерой Raspberry Pi.
3. Потоковый захват кадров: обеспечивает плавный предпросмотр.
4. Управление файлами: раскладывает снимки по каталогам с метками.

Ключевые функции

• initialize_camera(): настраивает экземпляр Picamera2.
• get_frame(): непрерывно захватывает кадры для предпросмотра.
• generate_frames(): отдаёт кадры для живой видеотрансляции.
• shutdown_server(): устанавливает событие остановки, останавливает камеру и выключает сервер Flask.
• index(): обрабатывает страницу ввода метки.
• capture_page(): выводит основной интерфейс захвата.
• video_feed(): показывает живой предпросмотр для наведения камеры.
• capture_image(): сохраняет изображение с текущей меткой.
• stop(): останавливает процесс захвата и выводит сводку.

Порядок работы

1. Запустите скрипт на Raspberry Pi.
2. Откройте веб-интерфейс в браузере.
3. Введите метку для изображений, которые хотите снять, и нажмите Start Capture.

4. Используйте живой предпросмотр, чтобы навести камеру.
5. Нажмите Capture Image, чтобы сохранить изображения под текущей меткой.

6. При необходимости меняйте метки для разных категорий, выбирая Change Label.
7. Нажмите Stop Capture, когда закончите, чтобы увидеть сводку.

Технические заметки

• Скрипт использует потоки (threading), чтобы одновременно захватывать кадры и обслуживать веб-страницы.
• Имена файлов содержат временную метку, чтобы каждое имя было уникальным.
• Веб-интерфейс адаптивен и доступен с мобильных устройств.

Возможности настройки

• Измените разрешение изображения в функции initialize_camera(). Здесь мы использовали QVGA $(320\times 240)$.
• Измените HTML-шаблоны, чтобы поменять внешний вид.
• Добавьте дополнительные шаги обработки или анализа изображений в функции capture_image().

Количество образцов в наборе данных

Снимите около 60 изображений для каждой категории (periquito, robot и background). Старайтесь снимать с разных ракурсов, на разных фонах и при разном освещении. На Raspi в итоге появится папка dataset, которая содержит 3 подпапки: periquito, robot и background — по одной для каждого класса изображений.

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

Обучение модели в Edge Impulse Studio

Для обучения модели мы будем использовать Edge Impulse Studio. Перейдите на страницу Edge Impulse, войдите в свой аккаунт и создайте новый проект:

Здесь можно клонировать похожий проект: Raspi - Img Class.

Набор данных

В Studio (EI Studio) мы пройдём четыре основных шага: Dataset (набор данных), Impulse, Tests (тесты) и Deploy (развёртывание на периферийном устройстве, в нашем случае на Raspi). Эти шаги помогают подготовить модель к работе на Raspi.

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

В Studio загрузите снятые данные, выполнив шаги:

1. Откройте вкладку Data acquisition и в разделе UPLOAD DATA загрузите файлы с компьютера в выбранные категории.
2. Оставьте разбиение исходного набора данных на обучающую и тестовую выборки за Studio и выберите метку (label) для каждой категории.
3. Повторите процедуру для всех трёх классов. В итоге в Studio должны появиться ваши «сырые данные»:

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

Проектирование Impulse

На этом этапе нужно определить, как:

• предобработать данные: изменить размер отдельных изображений и выбрать глубину цвета (RGB или оттенки серого);
• задать модель. В нашем случае это Transfer Learning (Images): дообучение предобученной модели классификации изображений MobileNet V2 на наших данных. Этот метод хорошо работает даже с относительно небольшими наборами изображений (около 180 изображений в нашем случае).

Перенос обучения (transfer learning) с MobileNet упрощает обучение модели, что особенно полезно в условиях ограниченных ресурсов и для проектов с небольшим числом размеченных данных. MobileNet, известная своей лёгкой архитектурой, — это предобученная модель, которая уже выучила полезные признаки на большом наборе данных (ImageNet).

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

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

Перейдите на вкладку Impulse Design и создайте impulse, задав размер изображения $160\times 160$ и сжатие (квадратная форма без обрезки). Выберите блоки Image и Transfer Learning. Сохраните Impulse.

Предобработка изображений

Все входные изображения QVGA/RGB565 будут преобразованы в 76 800 признаков $(160\times 160\times 3)$.

Нажмите Save parameters и на следующей вкладке выберите Generate features.

Модель

MobileNet — семейство эффективных свёрточных нейронных сетей, созданных для мобильного и встраиваемого зрения. Ключевые особенности MobileNet:

1. Лёгкость: оптимизирована для мобильных устройств и встраиваемых систем с ограниченными вычислительными ресурсами.
2. Скорость: быстрый инференс, подходящий для приложений реального времени.
3. Точность: сохраняет хорошую точность, несмотря на компактный размер.

MobileNetV2, представленная в 2018 году, улучшает исходную архитектуру MobileNet. Её ключевые особенности:

1. Инвертированные остаточные блоки (Inverted Residuals): используются инвертированные остаточные структуры, в которых соединения-шорткаты связывают тонкие «бутылочные» слои (bottleneck).
2. Линейные бутылочные слои (Linear Bottlenecks): в узких слоях удаляются нелинейности, чтобы не разрушать информацию.
3. Разделяемые по глубине свёртки (depthwise separable convolutions): сохраняется эта эффективная операция из MobileNetV1.

В нашем проекте мы выполним Transfer Learning с моделью MobileNetV2 160x160 1.0. Это значит, что изображения для обучения (и для будущего инференса) должны иметь входной размер $160\times 160$ пикселей и множитель ширины (Width Multiplier) 1,0 (полная ширина, без уменьшения). Эта конфигурация сбалансирована по размеру модели, скорости и точности.

Обучение модели

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

Заглянем «под капот» и посмотрим, как Edge Impulse реализует политику аугментации данных:

# Реализует политику аугментации данных
def augment_image(image, label):
    # Случайно отражаем изображение
    image = tf.image.random_flip_left_right(image)

    # Увеличиваем изображение, затем случайно обрезаем его до
    # исходных размеров
    resize_factor = random.uniform(1, 1.2)
    new_height = math.floor(resize_factor * INPUT_SHAPE[0])
    new_width = math.floor(resize_factor * INPUT_SHAPE[1])
    image = tf.image.resize_with_crop_or_pad(
        image, new_height, new_width
    )
    image = tf.image.random_crop(image, size=INPUT_SHAPE)

    # Меняем яркость изображения
    image = tf.image.random_brightness(image, max_delta=0.2)

    return image, label

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

Последний полносвязный слой нашей модели будет содержать 0 нейронов с dropout 10 % для предотвращения переобучения. Вот результат обучения:

Результат отличный: задержка около 35 мс (для Raspi-4), что должно дать около 30 кадров в секунду (fps) при инференсе. Raspi-Zero будет медленнее, а Raspi-5 — быстрее.

Компромисс между точностью и скоростью

Если нужен более быстрый инференс, модель следует обучать с меньшими значениями альфа (0,35; 0,5 и 0,75) или даже уменьшить размер входного изображения, пожертвовав частью точности. Однако уменьшение размера входного изображения и снижение альфа (множителя ширины) могут ускорить инференс MobileNet V2, и у них разные компромиссы. Сравним:

1. Уменьшение размера входного изображения:

Плюсы:

• Существенно снижает вычислительные затраты во всех слоях.
• Уменьшает использование памяти.
• Часто даёт заметный прирост скорости.

Минусы:

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

2. Уменьшение альфа (множителя ширины):

Плюсы:

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

Минусы:

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

Сравнение:

1. Влияние на скорость:

   • Уменьшение входного размера часто даёт более заметный прирост скорости, поскольку снижает вычисления квадратично (уменьшение ширины и высоты вдвое сокращает вычисления примерно на 75 %).
   • Уменьшение альфа даёт более линейное снижение вычислений.

2. Влияние на точность:

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

3. Архитектура модели:

   • Изменение входного размера не меняет архитектуру модели.
   • Изменение альфа меняет структуру модели, уменьшая количество каналов в каждом слое.

Рекомендации:

1. Если приложению не нужно обнаруживать мелкие детали и оно может мириться с небольшой потерей точности, уменьшение входного размера — часто самый эффективный способ ускорить инференс.
2. Уменьшение альфа предпочтительнее, если важно сохранить способность обнаруживать мелкие детали или нужен более сбалансированный компромисс между скоростью и точностью.
3. Для лучшего результата поэкспериментируйте с обоими способами:
   • Попробуйте MobileNet V2 с входными размерами, например $160\times 160$ или $96\times 96$;
   • Поэкспериментируйте со значениями альфа 1,0; 0,75; 0,5 или 0,35.
4. Всегда проверяйте разные конфигурации на своём оборудовании и на своём наборе данных, чтобы найти оптимальный баланс для вашей задачи.

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

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

Теперь возьмите набор данных, отложенный в начале проекта, и запустите на нём обученную модель. Результат снова отличный: 92,22 %.

Развёртывание модели

Как и в предыдущем разделе, модель можно развернуть в формате .tflite и запустить на Raspi с помощью Python.

На вкладке Dashboard перейдите к модели Transfer learning (int8 quantized) и нажмите значок загрузки:

Для сравнения скачайте также версию float32.

Перенесите модель с компьютера на Raspi (в ./models), например с помощью FileZilla. Также сделайте несколько снимков для инференса (в ./images).

Импортируйте нужные библиотеки:

import time
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import tflite_runtime.interpreter as tflite

Укажите пути и метки:

img_path = "./images/robot.jpg"
model_path = "./models/ei-raspi-img-class-int8-quantized-model.tflite"
labels = ["background", "periquito", "robot"]

Обратите внимание: модели, обученные в Edge Impulse Studio, выдают значения с индексами 0, 1, 2 и т. д., а метки следуют в алфавитном порядке.

Загрузите модель, выделите тензоры и получите информацию о входных и выходных тензорах:

# Загружаем модель TFLite
interpreter = tflite.Interpreter(model_path=model_path)
interpreter.allocate_tensors()

# Получаем входные и выходные тензоры
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

Важное отличие: dtype входных данных модели теперь int8, то есть входные значения лежат в диапазоне от –128 до +127, тогда как каждый пиксель нашего изображения — от 0 до 255. Поэтому изображение нужно предобработать. Проверим:

input_dtype = input_details[0]["dtype"]
input_dtype

numpy.int8

Откроем изображение и выведем его:

img = Image.open(img_path)
plt.figure(figsize=(4, 4))
plt.imshow(img)
plt.axis("off")
plt.show()

Выполним предобработку:

scale, zero_point = input_details[0]["quantization"]
img = img.resize(
    (input_details[0]["shape"][1], input_details[0]["shape"][2])
)
img_array = np.array(img, dtype=np.float32) / 255.0
img_array = (
    (img_array / scale + zero_point).clip(-128, 127).astype(np.int8)
)
input_data = np.expand_dims(img_array, axis=0)

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

input_data.shape, input_data.dtype

((1, 160, 160, 3), dtype('int8'))

Теперь выполним инференс. Также вычислим задержку модели:

# Инференс на Raspi-Zero
start_time = time.time()
interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()
end_time = time.time()
inference_time = (end_time - start_time) * 1000  # Переводим в миллисекунды
print("Inference time: {:.1f}ms".format(inference_time))

На инференс модель затратит около 125 мс на Raspi-Zero, то есть в 3–4 раза дольше, чем на Raspi-5.

Теперь получим метки и вероятности на выходе. Важно отметить, что модель, обученная в Edge Impulse Studio, имеет softmax на выходе (в отличие от исходной MobileNet V2), поэтому в качестве «вероятностей» нужно использовать сырой выход модели.

# Получаем результаты и сопоставляем их с классами
predictions = interpreter.get_tensor(output_details[0]["index"])[0]

# Получаем индексы top-k результатов
top_k_results = 3
top_k_indices = np.argsort(predictions)[::-1][:top_k_results]

# Получаем параметры квантования
scale, zero_point = output_details[0]["quantization"]

# Деквантуем выход
dequantized_output = (
    predictions.astype(np.float32) - zero_point
) * scale
probabilities = dequantized_output

print("\n\t[PREDICTION]        [Prob]\n")
for i in range(top_k_results):
    print(
        "\t{:20}: {:.2f}%".format(
            labels[top_k_indices[i]],
            probabilities[top_k_indices[i]] * 100,
        )
    )

Изменим ранее созданную функцию так, чтобы она работала с моделями разных типов:

def image_classification(
    img_path, model_path, labels, top_k_results=3, apply_softmax=False
):
    # Загружаем изображение
    img = Image.open(img_path)
    plt.figure(figsize=(4, 4))
    plt.imshow(img)
    plt.axis("off")

    # Загружаем модель TFLite
    interpreter = tflite.Interpreter(model_path=model_path)
    interpreter.allocate_tensors()

    # Получаем входные и выходные тензоры
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    # Предобработка
    img = img.resize(
        (input_details[0]["shape"][1], input_details[0]["shape"][2])
    )

    input_dtype = input_details[0]["dtype"]

    if input_dtype == np.uint8:
        input_data = np.expand_dims(np.array(img), axis=0)
    elif input_dtype == np.int8:
        scale, zero_point = input_details[0]["quantization"]
        img_array = np.array(img, dtype=np.float32) / 255.0
        img_array = (
            (img_array / scale + zero_point)
            .clip(-128, 127)
            .astype(np.int8)
        )
        input_data = np.expand_dims(img_array, axis=0)
    else:  # float32
        input_data = (
            np.expand_dims(np.array(img, dtype=np.float32), axis=0)
            / 255.0
        )

    # Инференс на Raspi-Zero
    start_time = time.time()
    interpreter.set_tensor(input_details[0]["index"], input_data)
    interpreter.invoke()
    end_time = time.time()
    inference_time = (end_time - start_time) * 1000  # Переводим в миллисекунды

    # Получаем результаты
    predictions = interpreter.get_tensor(output_details[0]["index"])[0]

    # Получаем индексы top-k результатов
    top_k_indices = np.argsort(predictions)[::-1][:top_k_results]

    # Обрабатываем выход в зависимости от его типа
    output_dtype = output_details[0]["dtype"]
    if output_dtype in [np.int8, np.uint8]:
        # Деквантуем выход
        scale, zero_point = output_details[0]["quantization"]
        predictions = (
            predictions.astype(np.float32) - zero_point
        ) * scale

    if apply_softmax:
        # Применяем softmax
        exp_preds = np.exp(predictions - np.max(predictions))
        probabilities = exp_preds / np.sum(exp_preds)
    else:
        probabilities = predictions

    print("\n\t[PREDICTION]        [Prob]\n")
    for i in range(top_k_results):
        print(
            "\t{:20}: {:.1f}%".format(
                labels[top_k_indices[i]],
                probabilities[top_k_indices[i]] * 100,
            )
        )
    print("\n\tInference time: {:.1f}ms".format(inference_time))

Протестируем её на разных изображениях с int8-квантованной моделью (160x160, alpha = 1,0):

Для проверки скачаем модель меньшего размера, например обученную для Nicla Vision Lab (int8-квантованная модель, $96\times 96$, alpha = 0,1). Можно использовать ту же функцию:

Точность модели немного снизилась, но результат всё ещё приемлем, поскольку наша модель не ищет много деталей. По задержке на Raspi-Zero модель работает примерно в десять раз быстрее.

Классификация изображений в реальном времени

Создадим приложение, которое в реальном времени снимает изображения USB-камерой и показывает результат классификации.

Через nano в терминале сохраните приведённый ниже код, например как img_class_live_infer.py.

from flask import (Flask, Response, render_template_string,
                   request, jsonify)
from picamera2 import Picamera2
import io
import threading
import time
import numpy as np
from PIL import Image
import tflite_runtime.interpreter as tflite
from queue import Queue, Empty

app = Flask(__name__)

# Глобальные переменные
picam2 = None
frame = None
frame_lock = threading.Lock()
is_classifying = False
confidence_threshold = 0.8
model_path = "./models/ei-raspi-img-class-int8-quantized-model.tflite"
labels = ['background', 'periquito', 'robot']
interpreter = None
classification_queue = Queue(maxsize=1)

def initialize_camera():
    global picam2
    picam2 = Picamera2()
    config = picam2.create_preview_configuration(
        main={"size": (320, 240)}
    )
    picam2.configure(config)
    picam2.start()
    time.sleep(2)  # Ждём, пока камера прогреется

def get_frame():
    global frame
    while True:
        stream = io.BytesIO()
        picam2.capture_file(stream, format='jpeg')
        with frame_lock:
            frame = stream.getvalue()
        time.sleep(0.1)  # Захватываем кадры чаще

def generate_frames():
    while True:
        with frame_lock:
            if frame is not None:
                yield (
                   b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n'
                   + frame + b'\r\n'
                )
        time.sleep(0.1)

def load_model():
    global interpreter
    if interpreter is None:
        interpreter = tflite.Interpreter(model_path=model_path)
        interpreter.allocate_tensors()
    return interpreter

def classify_image(img, interpreter):
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    img = img.resize((input_details[0]['shape'][1],
                      input_details[0]['shape'][2]))
    input_data = np.expand_dims(np.array(img), axis=0).astype(input_details[0]['dtype'])

    interpreter.set_tensor(input_details[0]['index'], input_data)
    interpreter.invoke()

    predictions = interpreter.get_tensor(output_details[0]
                                         ['index'])[0]
    # Обрабатываем выход в зависимости от его типа
    output_dtype = output_details[0]['dtype']
    if output_dtype in [np.int8, np.uint8]:
        # Деквантуем выход
        scale, zero_point = output_details[0]['quantization']
        predictions = (predictions.astype(np.float32) -
                       zero_point) * scale
    return predictions

def classification_worker():
    interpreter = load_model()
    while True:
        if is_classifying:
            with frame_lock:
                if frame is not None:
                    img = Image.open(io.BytesIO(frame))
            predictions = classify_image(img, interpreter)
            max_prob = np.max(predictions)
            if max_prob >= confidence_threshold:
                label = labels[np.argmax(predictions)]
            else:
                label = 'Uncertain'
            classification_queue.put({
                 'label': label,
                 'probability': float(max_prob)
            })
        time.sleep(0.1)  # При необходимости настройте

@app.route('/')
def index():
   return render_template_string('''
      <!DOCTYPE html>
      <html>
      <head>
          <title>Image Classification</title>
          <script
          	src="https://code.jquery.com/jquery-3.6.0.min.js">
          </script>
          <script>
              function startClassification() {
                  $.post('/start');
                  $('#startBtn').prop('disabled', true);
                  $('#stopBtn').prop('disabled', false);
              }
              function stopClassification() {
                  $.post('/stop');
                  $('#startBtn').prop('disabled', false);
                  $('#stopBtn').prop('disabled', true);
              }
              function updateConfidence() {
                  var confidence = $('#confidence').val();
                  $.post('/update_confidence',
                         {confidence: confidence}
                        );
              }
              function updateClassification() {
                  $.get('/get_classification', function(data) {
                    $('#classification').text(data.label + ': '
                    + data.probability.toFixed(2));
                  });
              }
              $(document).ready(function() {
                  setInterval(updateClassification, 100);
                  // Обновляем каждые 100 мс
              });
          </script>
      </head>
      <body>
          <h1>Image Classification</h1>
          <img src="{{ url_for('video_feed') }}"
               width="640"
               height="480" />

          <br>
          <button id="startBtn"
                  onclick="startClassification()">
            Start Classification
          </button>

          <button id="stopBtn"
                  onclick="stopClassification()"
                  disabled>
            Stop Classification
          </button>

          <br>
          <label for="confidence">Confidence Threshold:</label>
          <input type="number"
                 id="confidence"
                 name="confidence"
                 min="0" max="1"
                 step="0.1"
                 value="0.8"
                 onchange="updateConfidence()" />

          <br>
          <div id="classification">
             Waiting for classification...
          </div>

      </body>
      </html>
   ''')

@app.route('/video_feed')
def video_feed():
    return Response(
       generate_frames(),
       mimetype='multipart/x-mixed-replace; boundary=frame'
    )

@app.route('/start', methods=['POST'])
def start_classification():
    global is_classifying
    is_classifying = True
    return '', 204

@app.route('/stop', methods=['POST'])
def stop_classification():
    global is_classifying
    is_classifying = False
    return '', 204

@app.route('/update_confidence', methods=['POST'])
def update_confidence():
    global confidence_threshold
    confidence_threshold = float(request.form['confidence'])
    return '', 204

@app.route('/get_classification')
def get_classification():
    if not is_classifying:
        return jsonify({'label': 'Not classifying',
                       'probability': 0})
    try:
        result = classification_queue.get_nowait()
    except Empty:
        result = {'label': 'Processing', 'probability': 0}
    return jsonify(result)

if __name__ == '__main__':
    initialize_camera()
    threading.Thread(target=get_frame, daemon=True).start()
    threading.Thread(target=classification_worker,
                     daemon=True).start()
    app.run(host='0.0.0.0', port=5000, threaded=True)

В терминале выполните:

python3 img_class_live_infer.py

И откройте веб-интерфейс:

• На самой Raspberry Pi (если есть графический интерфейс): откройте веб-браузер и перейдите по адресу http://localhost:5000.
• С другого устройства в той же сети: откройте веб-браузер и перейдите по адресу http://<raspberry_pi_ip>:5000 (замените <raspberry_pi_ip> на IP-адрес вашей Raspberry Pi). Например: http://192.168.4.210:5000/

Вот несколько скриншотов приложения, запущенного на внешнем компьютере:

Видео работы приложения можно посмотреть на YouTube: ссылка на видео.

Код создаёт веб-приложение для классификации изображений в реальном времени на Raspberry Pi с модулем камеры и моделью TensorFlow Lite. Приложение использует Flask для веб-интерфейса, где можно видеть изображение с камеры и результаты классификации в реальном времени.

Ключевые компоненты

1. Веб-приложение Flask: отдаёт пользовательский интерфейс и обрабатывает запросы.
2. PiCamera2: захватывает изображения с модуля камеры Raspberry Pi.
3. TensorFlow Lite: запускает модель классификации изображений.
4. Потоки (Threading): управляют параллельными операциями для плавной работы.

Основные возможности

• Вывод изображения с камеры в реальном времени
• Классификация изображений в реальном времени
• Настраиваемый порог уверенности
• Запуск и остановка классификации по требованию

Структура кода

1. Импорты и настройка:

   • Flask для веб-приложения
   • PiCamera2 для управления камерой
   • TensorFlow Lite для инференса
   • Threading и Queue для параллельных операций

2. Глобальные переменные:

   • Управление камерой и кадрами
   • Управление классификацией
   • Информация о модели и метках

3. Функции камеры:

   • initialize_camera(): настраивает PiCamera2
   • get_frame(): непрерывно захватывает кадры
   • generate_frames(): отдаёт кадры для веб-трансляции

4. Функции модели:

   • load_model(): загружает модель TFLite
   • classify_image(): выполняет инференс для одного изображения

5. Рабочий поток классификации:

   • Работает в отдельном потоке
   • Непрерывно классифицирует кадры, пока включена классификация
   • Обновляет очередь последними результатами

6. Маршруты Flask:

   • /: отдаёт главную HTML-страницу
   • /video_feed: передаёт видеопоток с камеры
   • /start и /stop: управляют классификацией
   • /update_confidence: меняет порог уверенности
   • /get_classification: возвращает последний результат классификации

7. HTML-шаблон:

   • Показывает изображение с камеры и результаты классификации
   • Содержит элементы управления запуском, остановкой и настройками

8. Главный блок выполнения:

   • Инициализирует камеру и запускает нужные потоки
   • Запускает приложение Flask

Ключевые понятия

1. Параллельные операции: потоки обрабатывают захват с камеры и классификацию отдельно от веб-сервера.
2. Обновления в реальном времени: результаты классификации обновляются часто, без перезагрузки страницы.
3. Повторное использование модели: модель TFLite загружается один раз и используется повторно, что эффективно.
4. Гибкая настройка: пользователь может менять порог уверенности на лету.

Использование

1. Убедитесь, что все зависимости установлены.
2. Запустите скрипт на Raspberry Pi с модулем камеры.
3. Откройте веб-интерфейс в браузере, используя IP-адрес Raspberry Pi.
4. Запустите классификацию и при необходимости настройте параметры.

Итоги

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

Мы прошли весь конвейер проекта классификации изображений: от сбора данных и обучения модели в Edge Impulse Studio до развёртывания и запуска инференса на Raspi. В процессе выделилось несколько ключевых моментов:

1. Важность правильного сбора данных и предобработки для обучения эффективных моделей.
2. Сила переноса обучения: можно использовать предобученные модели, такие как MobileNet V2, для эффективного обучения на ограниченных данных.
3. Компромиссы между точностью модели и скоростью инференса, особенно важные для периферийных устройств.
4. Реализация классификации в реальном времени через веб-интерфейс, что демонстрирует практическое применение.

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

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

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

Этот проект служит основой для более сложных приложений компьютерного зрения и побуждает к дальнейшему изучению периферийного ИИ и IoT. Будь то промышленная автоматизация, «умный дом» или мониторинг окружающей среды, навыки и концепции, рассмотренные здесь, дают надёжную отправную точку для широкого круга проектов.

Ресурсы

• Набор данных (пример)
• Тестовый блокнот настройки на Raspi
• Блокнот классификации изображений на Raspi
• CNN для классификации набора данных Cifar-10 в Colab
• Cifar 10 — классификация изображений на Raspi
• Python-скрипты
• Проект Edge Impulse

Малые языковые модели (SLM)

Промпт DALL·E: иллюстрация в стиле мультфильма 1950-х, на которой Raspberry Pi запускает малую языковую модель на периферийном устройстве. Raspberry Pi оформлена в ретрофутуристическом стиле, с закруглёнными краями и хромированными деталями, и подключена к игривым мультяшным датчикам и устройствам. Вокруг плывут речевые пузыри, символизирующие обработку языка, а фон представляет собой причудливый пейзаж из связанных между собой устройств, проводов и маленьких гаджетов, нарисованных в винтажном мультяшном стиле. Цветовая палитра использует мягкие пастельные тона и жирные контуры, типичные для мультфильмов 1950-х, что придаёт сцене весёлую и ностальгическую атмосферу.

Обзор

В быстро развивающейся области искусственного интеллекта периферийные вычисления открывают возможность перенести функции, которые традиционно доступны только мощным централизованным серверам, ближе к источнику данных. Эта лабораторная работа посвящена практической интеграции небольших версий традиционных больших языковых моделей (LLM) в Raspberry Pi 5. Так это периферийное устройство превращается в ИИ-узел, способный обрабатывать данные на месте в реальном времени.

По мере того как большие языковые модели растут в размере и сложности, малые языковые модели (SLM) становятся привлекательной альтернативой для периферийных устройств: они обеспечивают баланс между производительностью и эффективным использованием ресурсов. Запуская такие модели непосредственно на Raspberry Pi, мы можем создавать отзывчивые приложения с защитой приватности, которые работают даже там, где интернет ограничен или отсутствует.

Эта лабораторная работа проведёт вас через установку, оптимизацию и использование SLM на Raspberry Pi. Мы изучим установку и применение Ollama — открытой платформы, которая позволяет запускать LLM локально на наших машинах: настольных компьютерах или периферийных устройствах, таких как Raspberry Pi или NVIDIA Jetson. Ollama спроектирована эффективной, масштабируемой и простой в использовании, поэтому подходит для развёртывания моделей ИИ, например Microsoft Phi, Google Gemma, Meta Llama и LLaVA (мультимодальная модель). Мы интегрируем некоторые из этих моделей в проекты с помощью экосистемы Python и изучим их потенциал в реальных сценариях (или хотя бы наметим такое направление).

Настройка

В предыдущих лабораторных работах можно было использовать любую модель Raspi, но здесь выбор — Raspberry Pi 5 (Raspi-5). Это надёжная платформа, которая заметно превосходит предыдущую версию 4. Она оснащена процессором Broadcom BCM2712 — 64-битным четырёхъядерным Arm Cortex-A76 с частотой 2,4 ГГц, с криптографическим расширением и улучшенным кэшированием. В ней есть GPU VideoCore VII, два выхода HDMI® с разрешением 4Kp60 с поддержкой HDR и декодер HEVC 4Kp60. Доступны варианты памяти 4 ГБ и 8 ГБ высокоскоростной LPDDR4X SDRAM; для запуска SLM мы выбираем 8 ГБ. Также есть расширяемое хранилище через слот microSD и интерфейс PCIe 2.0 для быстрой периферии, например твердотельных накопителей M.2 SSD.

Для реальных приложений SLM SSD — лучший выбор, чем SD-карты.

Кстати, как рассказал Alasdair Allan, инференс непосредственно на CPU Raspberry Pi 5 — без ускорения на GPU — сейчас сопоставим по производительности с Coral TPU.

Подробнее см. полную статью: Benchmarking TensorFlow and TensorFlow Lite on Raspberry Pi 5.

Активный кулер Raspberry Pi

Для этой лабораторной работы мы рекомендуем установить Active Cooler — навесное охлаждающее решение для Raspberry Pi 5 (Raspi-5). Оно сочетает алюминиевый радиатор с вентилятором, управляемым температурой, чтобы Raspi-5 комфортно работал под высокой нагрузкой, например при запуске SLM.

Active Cooler имеет предустановленные термопрокладки для теплопередачи и крепится непосредственно к плате Raspberry Pi 5 пружинными фиксаторами. Прошивка Raspberry Pi управляет им автоматически: при 60 °C включается вентилятор, при 67,5 °C его скорость увеличивается, а при 75 °C он работает на полной скорости. Когда температура опускается ниже этих порогов, вентилятор автоматически замедляется.

Чтобы предотвратить перегрев, все платы Raspberry Pi начинают снижать частоту процессора (троттлинг) при температуре 80 °C, а при достижении максимальной температуры 85 °C троттлинг усиливается (подробнее здесь).

Генеративный ИИ (GenAI)

Генеративный ИИ — это система искусственного интеллекта, способная создавать новый, оригинальный контент в разных форматах: текст, изображения, аудио и видео. Такие системы изучают закономерности в существующих данных и используют их, чтобы генерировать новые результаты, которых раньше не было. Большие языковые модели (LLM), малые языковые модели (SLM) и мультимодальные модели можно считать видами GenAI, если они используются для генеративных задач.

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

Большие языковые модели (LLM)

Большие языковые модели (LLM) — это продвинутые системы искусственного интеллекта, которые понимают, обрабатывают и генерируют человекоподобный текст. Такие модели характеризуются огромным масштабом: объёмом данных, на которых они обучаются, и количеством параметров. Ключевые аспекты LLM:

1. Размер: LLM обычно содержат миллиарды параметров. Например, у GPT-3 175 миллиардов параметров, а некоторые новые модели превышают триллион.

2. Обучающие данные: их обучают на огромных объёмах текста, часто включающих книги, веб-сайты и другие разнообразные источники; это сотни гигабайт или даже терабайты текста.

3. Архитектура: большинство LLM используют архитектуры на основе трансформеров, которые позволяют обрабатывать и генерировать текст, одновременно «обращая внимание» на разные части входных данных.

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

   • генерацию текста;
   • перевод;
   • суммаризацию;
   • ответы на вопросы;
   • генерацию кода;
   • логические рассуждения.

5. Обучение на нескольких примерах (few-shot learning): они часто могут понять и выполнить новую задачу по нескольким примерам или инструкциям.

6. Ресурсоёмкость: из-за своего размера LLM обычно требуют значительных вычислительных ресурсов и часто нуждаются в мощных GPU или TPU.

7. Непрерывное развитие: область LLM быстро развивается, постоянно появляются новые модели и методы.

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

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

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

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

Закрытые и открытые модели

Закрытые модели, также называемые проприетарными, — это модели ИИ, внутренняя работа, код и обучающие данные которых не раскрываются публично. Примеры: GPT-4 (OpenAI), Claude (Anthropic), Gemini (Google).

Открытые модели, также известные как модели с открытым исходным кодом, — это модели ИИ, базовый код, архитектура и часто обучающие данные которых публично доступны. Примеры: Gemma (Google), LLaMA (Meta) и Phi (Microsoft).

Открытые модели особенно важны для запуска на периферийных устройствах, таких как Raspberry Pi, поскольку их легче адаптировать, оптимизировать и развернуть в условиях ограниченных ресурсов. Тем не менее важно проверять их лицензии: открытые модели распространяются по разным лицензиям с открытым исходным кодом, которые могут влиять на использование в коммерческих приложениях. У закрытых моделей условия использования чёткие, хотя и ограничительные.

Адаптировано по [arXiv 2304.13712](https://arxiv.org/abs/2304.13712)

Малые языковые модели (SLM)

В контексте периферийных вычислений на таких устройствах, как Raspberry Pi, полномасштабные LLM обычно слишком велики и ресурсоёмки, чтобы работать на них напрямую. Это ограничение стимулировало разработку более компактных и эффективных моделей — малых языковых моделей (SLM).

SLM — это компактные версии LLM, созданные для эффективной работы на устройствах с ограниченными ресурсами: смартфонах, IoT-устройствах и одноплатных компьютерах вроде Raspberry Pi. Эти модели значительно меньше по размеру и требованиям к вычислениям, чем их крупные аналоги, и при этом сохраняют впечатляющие возможности понимания и генерации языка.

Ключевые характеристики SLM:

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

2. Меньший объём памяти: требуется не больше нескольких гигабайт памяти, а не десятки или сотни гигабайт.

3. Более быстрый инференс: могут генерировать ответы за миллисекунды или секунды на периферийных устройствах.

4. Энергоэффективность: потребляют меньше энергии, что делает их подходящими для устройств с батарейным питанием.

5. Сохранение приватности: обработка выполняется на устройстве, без отправки данных на облачные серверы.

6. Работа без подключения: могут работать без подключения к интернету.

SLM достигают компактности благодаря разным методам: дистилляции знаний (knowledge distillation), обрезке (pruning) и квантованию. Хотя SLM могут не сравниться с крупными моделями по широте возможностей, они превосходно справляются с конкретными задачами и предметными областями, что делает их идеальными для целевых приложений на периферийных устройствах.

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

Примеры SLM включают сжатые версии моделей вроде Meta Llama, Microsoft PHI и Google Gemma. Эти модели позволяют решать широкий круг задач обработки естественного языка прямо на периферийных устройствах: от классификации текста и анализа тональности до ответов на вопросы и ограниченной генерации текста.

Подробнее о SLM: статья LLM Pruning and Distillation in Practice: The Minitron Approach описывает подход, который применяет обрезку и дистилляцию, чтобы получить SLM из LLM. А работа SMALL LANGUAGE MODELS: SURVEY, MEASUREMENTS, AND INSIGHTS представляет всесторонний обзор и анализ малых языковых моделей (SLM) — языковых моделей со 100 миллионами — 5 миллиардами параметров, предназначенных для устройств с ограниченными ресурсами.

Ollama

Ollama — это открытая платформа, которая позволяет запускать языковые модели (LM), большие или малые, локально на наших машинах. Вот ключевые моменты об Ollama:

1. Локальный запуск моделей: Ollama позволяет запускать LM на персональных компьютерах или периферийных устройствах, таких как Raspi-5, без облачных API-вызовов.

2. Простота использования: предоставляет простой интерфейс командной строки для загрузки, запуска и управления разными языковыми моделями.

3. Разнообразие моделей: Ollama поддерживает различные LLM, включая Phi, Gemma, Llama, Mistral и другие открытые модели.

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

5. Лёгкость: спроектирована эффективно и работает на доступном аппаратном обеспечении.

6. Интеграция через API: предлагает API для интеграции с другими приложениями и сервисами.

7. Фокус на приватности: запуск моделей локально решает проблемы конфиденциальности, связанные с отправкой данных на внешние серверы.

8. Кроссплатформенность: доступна для macOS, Windows и Linux (наш случай).

9. Активная разработка: регулярно обновляется новыми функциями и поддержкой моделей.

10. Развитие сообществом: выигрывает от вкладов сообщества и обмена моделями.

Чтобы узнать больше о том, что такое Ollama и как она работает, посмотрите короткое видео от Matt Williams, одного из основателей Ollama: смотреть на YouTube.

Matt также ведёт полностью бесплатный курс об Ollama, который мы рекомендуем: смотреть на YouTube.

Установка Ollama

Создадим и активируем виртуальное окружение для работы с Ollama:

python3 -m venv ~/ollama
source ~/ollama/bin/activate

Теперь выполним команду установки Ollama:

curl -fsSL https://ollama.com/install.sh | sh

В результате API будет работать в фоновом режиме по адресу 127.0.0.1:11434. Теперь мы можем запускать Ollama из терминала. Для начала проверим версию Ollama — это также подтвердит, что установка прошла успешно:

ollama -v

На странице библиотеки Ollama можно найти модели, которые поддерживает Ollama. Например, если отфильтровать по Most popular (самые популярные), увидим Meta Llama, Google Gemma, Microsoft Phi, LLaVa и другие модели.

Meta Llama 3.2 1B/3B

Установим и запустим нашу первую малую языковую модель, Llama 3.2 1B (и 3B). Серия Meta Llama 3.2 — это набор многоязычных генеративных языковых моделей размером 1 и 3 миллиарда параметров. Эти модели предназначены для обработки текстового ввода и генерации текстового вывода. Инструктивные варианты этой серии специально оптимизированы для многоязычных диалоговых приложений, включая задачи поиска информации и суммаризации с агентным подходом. По сравнению со многими существующими чат-моделями с открытым исходным кодом и проприетарными моделями инструктивные версии Llama 3.2 демонстрируют превосходные результаты в широко используемых отраслевых тестах.

Модели 1B и 3B были обрезаны (pruned) из Llama 8B, а затем в качестве целевых значений на уровне токенов использовались логиты моделей 8B и 70B (дистилляция на уровне токенов). Для восстановления качества применялась дистилляция знаний: обучение проводилось на 9 триллионах токенов. Модель 1B содержит 1,24 млрд параметров с квантованием в целые числа (Q8_0), а модель 3B — 3,12 млрд параметров с квантованием Q4_0. Их размеры составляют 1,3 ГБ и 2 ГБ соответственно. Окно контекста — 131 072 токена.

Установка и запуск модели

ollama run llama3.2:1b

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

>>> What is the capital of France?

Почти мгновенно мы получаем правильный ответ:

The capital of France is Paris.

Если при вызове модели использовать параметр --verbose, будет выведена статистика о её работе (модель загружается только при первом запуске команды).

Каждый показатель даёт представление о том, как модель обрабатывает входные данные и генерирует ответы. Вот расшифровка метрик:

• Total Duration (2,620170326 с): полное время от начала выполнения команды до завершения ответа. Оно включает загрузку модели, обработку входного запроса и генерацию ответа.
• Load Duration (39,947908 мс): время загрузки модели или необходимых компонентов в память. Если значение мало, возможно, модель была предзагружена или требовалась лишь минимальная настройка.
• Prompt Eval Count (32 токена): количество токенов во входном запросе. В NLP токены обычно являются словами или их частями, поэтому здесь учитываются все токены, которые модель обработала, чтобы понять запрос и ответить на него.
• Prompt Eval Duration (1,644773 с): время, которое модель тратит на обработку входного запроса. Оно составляет основную часть общего времени, то есть понимание запроса и подготовка ответа — самая трудоёмкая часть процесса.
• Prompt Eval Rate (19,46 токенов/с): скорость обработки токенов входного запроса. Она отражает быстродействие модели при понимании естественного языка.
• Eval Count (8 токенов): количество токенов в ответе модели; в данном случае это фраза «The capital of France is Paris.»
• Eval Duration (889,941 мс): время генерации ответа на основе обработанного входа. Оно заметно короче времени обработки запроса, а значит, генерация ответа менее сложна и вычислительно менее затратна, чем понимание запроса.
• Eval Rate (8,99 токена/с): аналогично скорости обработки запроса, показывает скорость генерации выходных токенов. Это важный показатель эффективности модели при генерации ответа.

Такой подробный разбор помогает понять вычислительные требования и характеристики производительности SLM, например Llama, на периферийных устройствах вроде Raspberry Pi 5. Видно, что обработка запроса занимает больше времени, тогда как сама генерация ответа проходит относительно быстрее. Этот анализ важен для оптимизации производительности и поиска узких мест в приложениях реального времени.

Загрузим и запустим модель 3B и сравним производительность на том же запросе:

Скорость генерации ниже: 5,3 токена/с против 9 токенов/с у меньшей модели.

На вопрос

>>> What is the distance between Paris and Santiago, Chile?

модель 1B ответила 9,841 kilometers (6,093 miles) — это неточно, а модель 3B ответила 7,300 miles (11,700 km) — это близко к правильному значению (11 642 км).

Спросим координаты Парижа:

>>> what is the latitude and longitude of Paris?

The latitude and longitude of Paris are 48.8567° N (48°55'
42" N) and 2.3510° E (2°22' 8" E), respectively.

Обе модели — 1B и 3B — дали правильные ответы.

Google Gemma 2 2B

Установим Gemma 2 — высокопроизводительную и эффективную модель, доступную в трёх размерах: 2B, 9B и 27B. Мы установим Gemma 2 2B — лёгкую модель, обученную на 2 триллионах токенов, которая даёт выдающиеся результаты, перенимая знания у более крупных моделей через дистилляцию. В модели 2,6 млрд параметров и квантование Q4_0, её размер — 1,6 ГБ. Окно контекста — 8192 токена.

Установка и запуск модели

ollama run gemma2:2b --verbose

После запуска команды появится приглашение Ollama, и можно задать вопрос, например:

>>> What is the capital of France?

Почти сразу получаем правильный ответ:

The capital of France is **Paris**. 🗼

И её статистика:

Видим, что Gemma 2:2B работает примерно так же быстро, как Llama 3.2:3B, но при меньшем числе параметров.

Другие примеры:

>>> What is the distance between Paris and Santiago, Chile?

The distance between Paris, France and Santiago, Chile is
approximately **7,000 miles (11,267 kilometers)**.

Keep in mind that this is a straight-line distance, and actual
travel distance can vary depending on the chosen routes and any
stops along the way. ✈️

Ответ тоже хороший, но менее точный, чем у Llama3.2:3B.

>>> what is the latitude and longitude of Paris?

You got it! Here are the latitudes and longitudes of Paris,
France:

* **Latitude**: 48.8566° N (north)
* **Longitude**: 2.3522° E (east)

Let me know if you'd like to explore more about Paris or its
location! 🗼🇫🇷

Хороший и точный ответ (немного многословнее, чем ответы Llama).

Microsoft Phi3.5 3.8B

Загрузим модель побольше, но всё ещё компактную: PHI3.5 — лёгкую современную открытую модель с 3,8 млрд параметров от Microsoft. Модель относится к семейству Phi-3, поддерживает контекст 128K токенов и языки: арабский, китайский, чешский, датский, нидерландский, английский, финский, французский, немецкий, иврит, венгерский, итальянский, японский, корейский, норвежский, польский, португальский, русский, испанский, шведский, тайский, турецкий и украинский.

Размер модели в байтах зависит от выбранного формата квантования. Он может варьироваться от квантования 2 бита (q2_k) размером 1,4 ГБ (выше производительность, ниже качество) до 16-битного (fp-16) размером 7,6 ГБ (ниже производительность, выше качество).

Запустим 4-битное квантование (Q4_0), которому нужно 2,2 ГБ оперативной памяти. Это компромисс между качеством ответов и производительностью.

ollama run phi3.5:3.8b --verbose

Загрузить модель можно и командой run, и командой pull. Ollama запоминает загруженные модели: если Phi3 ещё нет на устройстве, Ollama скачает её перед запуском.

Введём тот же запрос, что и раньше:

>>> What is the capital of France?

The capital of France is Paris. It' extradites significant
historical, cultural, and political importance to the country as
well as being a major European city known for its art, fashion,
gastronomy, and culture. Its influence extends beyond national
borders, with millions of tourists visiting each year from around
the globe. The Seine River flows through Paris before it reaches
the broader English Channel at Le Havre. Moreover, France is one
of Europe's leading economies with its capital playing a key role

...

Ответ получился очень «многословным», поэтому зададим более удачный запрос:

В этом случае ответ всё равно был длиннее, чем мы ожидали, со скоростью генерации 2,25 токена/с, то есть более чем вдвое медленнее, чем у Gemma и Llama.

Выбор наиболее подходящего запроса (prompt) — один из самых важных навыков при работе с LLM, независимо от их размера.

Когда мы задали те же вопросы о расстоянии и координатах, ответ о расстоянии 13,507 kilometers (8,429 miles) оказался неверным, а координаты — приемлемыми. Ответы снова могли бы быть менее многословными (более 200 токенов на каждый ответ).

Любую модель можно использовать как ассистента, поскольку её скорость вполне приемлема. Однако по состоянию на 24 сентября 2023 года для такой задачи лучше подходит Llama2:3B. Стоит попробовать и другие модели в зависимости от ваших потребностей. 🤗 Open LLM Leaderboard поможет оценить лучшие модели по размеру, результатам тестов, лицензии и т. д.

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

Мультимодальные модели

Мультимодальные модели — это системы искусственного интеллекта (ИИ), которые могут обрабатывать и понимать информацию из нескольких источников: изображений, текста, аудио и видео. В нашем контексте мультимодальные LLM могут принимать в качестве запросов разные входные данные, включая текст, изображения и аудио, и преобразовывать их в выходные данные разных типов, а не только того же типа.

Мы будем работать с LLaVA-Phi-3 — доработанной моделью LLaVA на основе Phi 3 Mini 4k. По результатам тестов она сопоставима с исходной моделью LLaVA (Large Language and Vision Assistant).

LLaVA-Phi-3 — это крупная мультимодальная модель, обученная сквозным образом, которая понимает визуальные данные (изображения) и текстовые инструкции и генерирует контент на их основе. Она сочетает возможности визуального энкодера и языковой модели, чтобы обрабатывать мультимодальные входные данные и отвечать на них.

Установим модель:

ollama run llava-phi3:3.8b --verbose

Начнём с текстового ввода:

>>> You are a helpful AI assistant.
    What is the capital of France?

As an AI language model, I can tell you that the capital of
France is Paris. It's not only the largest city in the country
but also serves as its political and administrative center.
Paris is known for its iconic landmarks such as the Eiffel
Tower, Notre-Dame Cathedral, and the Louvre Museum. The city
has a rich history, beautiful architecture, and is widely
considered to be one of the most romantic cities in the world.

Ответ занял около 30 секунд, скорость генерации — 3,93 токена/с. Неплохо!

Теперь передадим модели изображение. Для этого создадим рабочую папку:

cd Documents/
mkdir OLLAMA
cd OLLAMA

Скачаем изображение размером $640\times 320$, например из Википедии: Paris, France:

С помощью FileZilla, например, загрузим изображение в папку OLLAMA на Raspi-5 и назовём его image_test_1.jpg. Нам понадобится полный путь к изображению (его можно узнать командой pwd):

/home/username/Documents/OLLAMA/image_test_1.jpg

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

Введём такой запрос:

>>> Describe the image /home/username/Documents/OLLAMA/\
                        image_test_1.jpg

Результат получился хорошим, но общая задержка оказалась значительной: почти 4 минуты на инференс.

Проверка локальных ресурсов

С помощью htop можно отслеживать ресурсы, используемые устройством:

htop

Пока модель работает, можно проверять ресурсы:

Все четыре ядра CPU работают почти на 100 % своей мощности, а объём памяти с загруженной моделью составляет 3.24 GB. После выхода из Ollama память снижается примерно до 377 MB (без рабочего стола).

Также важно следить за температурой. При работе Raspberry с рабочим столом температуру можно видеть на панели задач:

Если Raspi работает без монитора (headless), температуру можно проверить командой:

vcgencmd measure_temp

Если устройство простаивает, температура составляет около 50 °C при загрузке CPU 1 %. Во время инференса, когда CPU загружены на 100 %, температура может подняться почти до 70 °C. Это нормально: значит, активный кулер работает и удерживает температуру ниже предела 80/85 °C.

Библиотека Ollama для Python

До сих пор мы изучали возможности диалога с SLM через командную строку в терминале. Однако мы хотим интегрировать эти модели в наши проекты, поэтому логичнее использовать Python. Хорошая новость: у Ollama есть такая библиотека.

Библиотека Ollama для Python упрощает взаимодействие с продвинутыми LLM, позволяя получать более сложные ответы и реализовывать дополнительные возможности. Она также даёт самый простой способ интегрировать проекты на Python 3.8+ с Ollama.

Чтобы лучше понять, как создавать приложения с Ollama на Python, можно посмотреть видео Matt Williams, например это: смотреть на YouTube.

Установка:

В терминале выполните команду:

pip install ollama

Для создания Python-скрипта понадобится текстовый редактор или IDE. Если вы работаете с Raspberry Pi OS на рабочем столе, по умолчанию уже установлено несколько вариантов, например Thonny и Geany (открываются через [Menu][Programming]). Другие IDE, например Visual Studio Code, можно загрузить через [Menu][Recommended Software]. Когда откроется окно, перейдите в [Programming], выберите нужный вариант и нажмите [Apply].

Если вы предпочитаете разрабатывать в Jupyter Notebook:

pip install jupyter
jupyter notebook --generate-config

Чтобы запустить Jupyter Notebook, выполните команду (замените IP-адрес на свой):

jupyter notebook --ip=192.168.4.209 --no-browser

В терминале появится локальный URL-адрес, по которому можно открыть блокнот:

Получить доступ к блокноту можно с другого компьютера: введите в веб-браузере IP-адрес Raspberry Pi и токен из терминала (скопируйте его оттуда).

В рабочем каталоге Raspi создадим новый блокнот Python 3.

Запустим очень простой скрипт, чтобы проверить установленные модели:

import ollama

ollama.list()

Все модели будут выведены в виде словаря, например:

  {'name': 'gemma2:2b',
   'model': 'gemma2:2b',
   'modified_at': '2024-09-24T19:30:40.053898094+01:00',
   'size': 1629518495,
   'digest': (
     '8ccf136fdd5298f3ffe2d69862750ea7fb56555fa4d5b18c0'
     '4e3fa4d82ee09d7'
    ),

   'details': {'parent_model': '',
    'format': 'gguf',
    'family': 'gemma2',
    'families': ['gemma2'],
    'parameter_size': '2.6B',
    'quantization_level': 'Q4_0'}}]}

Повторим один из вопросов, которые мы задавали раньше, но теперь с помощью ollama.generate() из библиотеки Ollama для Python. Этот API генерирует ответ на заданный запрос с помощью указанной модели. Это потоковая конечная точка, поэтому ответ приходит серией фрагментов. Итоговый объект ответа содержит статистику и дополнительные данные о запросе.

MODEL = "gemma2:2b"
PROMPT = "What is the capital of France?"

res = ollama.generate(model=MODEL, prompt=PROMPT)
print(res)

Если запускаете код как Python-скрипт, сохраните его, например, как test_ollama.py. Запустить его можно в IDE или прямо в терминале. Помните, что при запуске отдельного скрипта модель всегда нужно указывать явно.

python test_ollama.py

В результате мы получим ответ модели в формате JSON:

{
  'model': 'gemma2:2b',
  'created_at': '2024-09-25T14:43:31.869633807Z',
  'response': 'The capital of France is **Paris**.\n',
  'done': True,
  'done_reason': 'stop',
  'context': [
      106, 1645, 108, 1841, 603, 573, 6037, 576, 6081, 235336,
      107, 108, 106, 2516, 108, 651, 6037, 576, 6081, 603, 5231,
      29437, 168428, 235248, 244304, 241035, 235248, 108
  ],
  'total_duration': 24259469458,
  'load_duration': 19830013859,
  'prompt_eval_count': 16,
  'prompt_eval_duration': 1908757000,
  'eval_count': 14,
  'eval_duration': 2475410000
}

Как видно, генерируется несколько видов информации, например:

• response: основной текст, который модель сгенерировала в ответ на наш запрос:

  • The capital of France is **Paris**. 🇫🇷

• context: идентификаторы токенов, представляющие входные данные и контекст, которые использовала модель. Токены — это числовые представления текста, которые языковая модель использует для обработки:

  [106, 1645, 108, 1841, 603, 573, 6037, 576, 6081, 235336,
   107, 108, 106, 2516, 108, 651, 6037, 576, 6081, 603,
   5231, 29437, 168428, 235248, 244304, 241035, 235248, 108]
  

Показатели производительности:

• total_duration: общее время выполнения операции в наносекундах. В данном случае примерно 24,26 секунды.
• load_duration: время загрузки модели или её компонентов в наносекундах. Около 19,83 секунды.
• prompt_eval_duration: время обработки запроса в наносекундах. Около 1,9 секунды.
• eval_count: количество токенов, обработанных при генерации. Здесь 14 токенов.
• eval_duration: время, за которое модель сгенерировала ответ, в наносекундах. Примерно 2,5 секунды.

Но нам нужен только текст ответа (response) и, возможно, для анализа общее время инференса. Поэтому изменим код так, чтобы извлекать их из словаря:

print(f"\n{res['response']}")
print(
    f"\n [INFO] Total Duration: "
    f"{res['total_duration']/1e9:.2f} seconds"
)

Теперь получаем:

The capital of France is **Paris**. 🇫🇷

 [INFO] Total Duration: 24.26 seconds

Использование Ollama.chat()

Другой способ получить ответ — ollama.chat(), который генерирует следующее сообщение в диалоге с указанной моделью. Это тоже потоковая конечная точка, поэтому ответ приходит серией фрагментов. Потоковую передачу можно отключить, указав "stream": false. Итоговый объект ответа также содержит статистику и дополнительные данные о запросе.

PROMPT_1 = "What is the capital of France?"

response = ollama.chat(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": PROMPT_1,
        },
    ],
)
resp_1 = response["message"]["content"]
print(f"\n{resp_1}")
print(
    f"\n [INFO] Total Duration: "
    f"{(response['total_duration']/1e9):.2f} seconds"
)

Ответ такой же, как и раньше.

Важный момент: при использовании ollama.generate() ответ «забывается» моделью после завершения инференса (запрос используется только один раз). Если же мы хотим сохранить диалог, нужно использовать ollama.chat(). Посмотрим, как это работает:

PROMPT_1 = "What is the capital of France?"
response = ollama.chat(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": PROMPT_1,
        },
    ],
)
resp_1 = response["message"]["content"]
print(f"\n{resp_1}")
print(
    f"\n [INFO] Total Duration: "
    f"{(response['total_duration']/1e9):.2f} seconds"
)

PROMPT_2 = "and of Italy?"
response = ollama.chat(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": PROMPT_1,
        },
        {
            "role": "assistant",
            "content": resp_1,
        },
        {
            "role": "user",
            "content": PROMPT_2,
        },
    ],
)
resp_2 = response["message"]["content"]
print(f"\n{resp_2}")
print(
    f"\n [INFO] Total Duration: "
    f"{(response['total_duration']/1e9):.2f} seconds"
)

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

Вот как ответила модель:

The capital of France is **Paris**. 🇫🇷

 [INFO] Total Duration: 2.82 seconds

The capital of Italy is **Rome**. 🇮🇹

 [INFO] Total Duration: 4.46 seconds

Получение описания изображения:

Так же, как мы использовали модель LlaVa-PHI-3 в командной строке для анализа изображения, это можно сделать и в Python. Используем то же изображение Парижа, но теперь с ollama.generate():

MODEL = "llava-phi3:3.8b"
PROMPT = "Describe this picture"

with open("image_test_1.jpg", "rb") as image_file:
    img = image_file.read()

response = ollama.generate(model=MODEL, prompt=PROMPT, images=[img])
print(f"\n{response['response']}")
print(
    f"\n [INFO] Total Duration: "
    f"{(response['total_duration']/1e9):.2f} seconds"
)

Вот результат:

This image captures the iconic cityscape of Paris, France. The
vantage point is high, providing a panoramic view of the Seine
River that meanders through the heart of the city. Several
bridges arch gracefully over the river, connecting different
parts of the city. The Eiffel Tower, an iron lattice structure
with a pointed top and two antennas on its summit, stands
tall in the background, piercing the sky. It is painted in a
light gray color, contrasting against the blue sky speckled
with white clouds.

The buildings that line the river are predominantly white or
beige, their uniform color palette broken occasionally by red
roofs peeking through. The Seine River itself appears calm
and wide, reflecting the city's architectural beauty in its
surface. On either side of the river, trees add a touch of
green to the urban landscape.

The image is taken from an elevated perspective, looking down
on the city. This viewpoint allows for a comprehensive view of
Paris's beautiful architecture and layout. The relative
positions of the buildings, bridges, and other structures
create a harmonious composition that showcases the city's charm.

In summary, this image presents a serene day in Paris, with its
architectural marvels - from the Eiffel Tower to the river-side
buildings - all bathed in soft colors under a clear sky.

 [INFO] Total Duration: 256.45 seconds

Модели потребовалось около 4 минут (256,45 с), чтобы вернуть подробное описание изображения.

В блокноте 10-Ollama_Python_Library можно найти эксперименты с библиотекой Ollama для Python.

Вызов функций

До сих пор мы видели, что, помещая ответ модели в переменную, его можно эффективно использовать в реальных проектах. Однако возникает серьёзная проблема: модель может давать разные ответы на один и тот же вход. Например, предположим, что в предыдущих примерах нам нужны только название столицы страны и её координаты, без дополнительной информации, даже при использовании многословных моделей вроде Microsoft Phi. Чтобы обеспечить стабильные ответы, можно использовать «вызов функций Ollama» (Ollama function call), который полностью совместим с API OpenAI.

Что такое «вызов функций»?

В современном искусственном интеллекте вызов функций с большими языковыми моделями (LLM) позволяет этим моделям выполнять действия, выходящие за рамки генерации текста. Интегрируясь с внешними функциями или API, LLM могут получать данные в реальном времени, автоматизировать задачи и взаимодействовать с различными системами.

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

Подробнее о вызове функций см. видео, сделанное Mervin Praison: смотреть на YouTube.

Создадим проект

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

Когда пользователь вводит название страны, модель возвращает название её столицы (строка), а также широту и долготу этого города (числа с плавающей точкой). Используя эти координаты, мы можем с помощью простой библиотеки Python (haversine) вычислить расстояние между двумя точками.

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

Сначала установим несколько библиотек. Помимо Haversine, главная из них — библиотека OpenAI для Python, которая обеспечивает удобный доступ к REST API OpenAI из любого приложения на Python 3.7+. Вторая — Pydantic (и instructor), надёжная библиотека проверки данных и управления настройками, созданная для повышения устойчивости и надёжности кода. Коротко говоря, Pydantic поможет гарантировать, что ответ модели всегда будет согласованным.

pip install haversine
pip install openai
pip install pydantic
pip install instructor

Теперь создадим Python-скрипт, который взаимодействует с нашей моделью (LLM), чтобы определить координаты столицы страны и вычислить расстояние от Сантьяго-де-Чили до этой столицы.

Разберём код по шагам.

1. Импорт библиотек

import sys
from haversine import haversine
from openai import OpenAI
from pydantic import BaseModel, Field
import instructor

• sys: предоставляет доступ к системным параметрам и функциям. Используется для получения аргументов командной строки.
• haversine: функция из библиотеки haversine, которая вычисляет расстояние между двумя географическими точками по формуле гаверсинусов.
• openAI: модуль для взаимодействия с API OpenAI (здесь он используется вместе с локальной установкой Ollama). Всё работает офлайн.
• pydantic: обеспечивает проверку данных и управление настройками с помощью аннотаций типов Python. Используется для описания структуры ожидаемых данных ответа.
• instructor: модуль, который «патчит» клиента OpenAI, чтобы он работал в определённом режиме (вероятно, связанном с обработкой структурированных данных).

2. Определение входных данных и модели

country = sys.argv[1]  # Получаем страну из
# аргументов командной строки
MODEL = "phi3.5:3.8b"  # Название модели для использования
mylat = -33.33  # Широта Сантьяго-де-Чили
mylon = -70.51  # Долгота Сантьяго-де-Чили

• country: в Python-скрипте название страны можно получить из аргументов командной строки. В Jupyter Notebook его можно задать вручную, например:
  • country = "France"
• MODEL: указывает используемую модель, в данном примере phi3.5.
• mylat и mylon: координаты Сантьяго-де-Чили, которые служат отправной точкой для расчёта расстояния.

3. Определение структуры данных ответа

class CityCoord(BaseModel):
    city: str = Field(..., description="Name of the city")
    lat: float = Field(
        ..., description="Decimal Latitude of the city"
    )
    lon: float = Field(
        ..., description="Decimal Longitude of the city"
    )

• CityCoord: модель Pydantic, которая определяет ожидаемую структуру ответа LLM. Она ожидает три поля: city (название города), lat (широта) и lon (долгота).

4. Настройка клиента OpenAI

client = instructor.patch(
    OpenAI(
        base_url="http://localhost:11434/v1",  # Базовый URL локального API
        # (Ollama)
        api_key="ollama",  # Ключ API
        # (не используется)
    ),
    mode=instructor.Mode.JSON,  # Режим для
    # структурированного вывода JSON
)

• OpenAI: эта настройка создаёт клиента OpenAI с локальным базовым URL и ключом API (ollama). Используется локальный сервер.
• instructor.patch: «патчит» клиента OpenAI, переводя его в режим JSON, что позволяет получать структурированный вывод, соответствующий модели Pydantic.

5. Генерация ответа

resp = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": f"return the decimal latitude and \
            decimal longitude of the capital of the {country}.",
        }
    ],
    response_model=CityCoord,
    max_retries=10,
)

• client.chat.completions.create: вызывает LLM для генерации ответа.
• model: указывает модель, которую нужно использовать (в нашем коде это phi3.5).
• messages: содержит запрос к LLM с просьбой вернуть широту и долготу столицы заданной страны.
• response_model: указывает, что ответ должен соответствовать модели CityCoord.
• max_retries: максимальное число повторных попыток, если запрос не удался.

6. Вычисление расстояния

distance = haversine((mylat, mylon), (resp.lat, resp.lon), unit="km")

print(
    f"Santiago de Chile is about {int(round(distance, -1))} "
    f"kilometers away from {resp.city}."
)

• haversine: вычисляет расстояние между Сантьяго-де-Чили и столицей, которую вернула LLM, по их координатам.
• (mylat, mylon): координаты Сантьяго-де-Чили.
• resp.city: название столицы страны.
• (resp.lat, resp.lon): координаты столицы, которые предоставил ответ LLM.
• unit = ‘km’: расстояние вычисляется в километрах.
• print: выводит расстояние, округлённое до ближайших 10 километров, с разделителями тысяч для удобства чтения.

Запуск кода

Если указать разные страны, например Францию, Колумбию и США, мы видим, что каждый раз получаем одну и ту же структурированную информацию:

Santiago de Chile is about 8,060 kilometers away from
    Washington, D.C..
Santiago de Chile is about 4,250 kilometers away from Bogotá.
Santiago de Chile is about 11,630 kilometers away from Paris.

Если запустить код как скрипт, результат будет выведен в терминале:

И расчёты довольно точны!

В блокноте 20-Ollama_Function_Calling можно найти эксперименты со всеми установленными моделями.

Добавление изображений

Пора собрать всё вместе! Изменим скрипт так, чтобы вместо названия страны (текстом) пользователь вводил изображение, а приложение на основе SLM возвращало город, изображённый на нём, и его географическое положение. Имея эти данные, мы можем вычислить расстояние, как и раньше.

Для простоты реализуем новый код в два шага. Сначала LLM проанализирует изображение и создаст его описание (текст). Этот текст передаётся другому экземпляру модели, которая извлечёт из него нужную информацию.

Начнём с импорта библиотек:

import sys
import time
from haversine import haversine
import ollama
from openai import OpenAI
from pydantic import BaseModel, Field
import instructor

Чтобы видеть изображение при запуске кода в Jupyter Notebook, также импортируем:

import matplotlib.pyplot as plt
from PIL import Image

Эти библиотеки не нужны, если код запускается как скрипт.

Теперь определим модель и локальные координаты:

MODEL = "llava-phi3:3.8b"
mylat = -33.33
mylon = -70.51

Можно скачать новое изображение, например Мачу-Пикчу из Википедии, и посмотреть его в блокноте:

# Загружаем изображение
img_path = "image_test_3.jpg"
img = Image.open(img_path)

# Выводим изображение
plt.figure(figsize=(8, 8))
plt.imshow(img)
plt.axis("off")
# plt.title("Image")
plt.show()

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

def image_description(img_path):
    with open(img_path, "rb") as file:
        response = ollama.chat(
            model=MODEL,
            messages=[
                {
                    "role": "user",
                    "content": """return the decimal latitude and \
                 decimal longitude of the city in the image, \
                 its name, and what country it is located""",
                    "images": [file.read()],
                },
            ],
            options={
                "temperature": 0,
            },
        )
    # print(response['message']['content'])
    return response["message"]["content"]

Для отладки можно вывести весь ответ целиком.

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

start_time = time.perf_counter()  # Запускаем таймер


class CityCoord(BaseModel):
    city: str = Field(
        ..., description="Name of the city in the image"
    )
    country: str = Field(
        ...,
        description=(
            "Name of the country where "
            "the city in the image is located"
        ),
    )
    lat: float = Field(
        ...,
        description=("Decimal latitude of the city in " "the image"),
    )
    lon: float = Field(
        ...,
        description=("Decimal longitude of the city in " "the image"),
    )


# Включает `response_model` в вызове create
client = instructor.patch(
    OpenAI(base_url="http://localhost:11434/v1", api_key="ollama"),
    mode=instructor.Mode.JSON,
)

image_description = image_description(img_path)
# Отправляем это описание модели
resp = client.chat.completions.create(
    model=MODEL,
    messages=[
        {
            "role": "user",
            "content": image_description,
        }
    ],
    response_model=CityCoord,
    max_retries=10,
    temperature=0,
)

Если вывести описание изображения, получим:

The image shows the ancient city of Machu Picchu, located in
Peru. The city is perched on a steep hillside and consists of
various structures made of stone. It is surrounded by lush
greenery and towering mountains. The sky above is blue with
scattered clouds.

Machu Picchu's latitude is approximately 13.5086° S, and its
longitude is around 72.5494° W.

А вторым ответом модели (resp) будет:

CityCoord(city='Machu Picchu', country='Peru', lat=-13.5086,
                lon=-72.5494)

Теперь можно выполнить «постобработку»: вычислить расстояние и подготовить итоговый ответ:

distance = haversine((mylat, mylon), (resp.lat, resp.lon), unit="km")

print(
    (
        f"\nThe image shows {resp.city}, with lat: "
        f"{round(resp.lat, 2)} and long: "
        f"{round(resp.lon, 2)}, located in "
        f"{resp.country} and about "
        f"{int(round(distance, -1)):,} kilometers "
        f"away from Santiago, Chile.\n"
    )
)

end_time = time.perf_counter()  # Останавливаем таймер
elapsed_time = end_time - start_time  # Вычисляем затраченное время
print(
    f"[INFO] ==> The code (running {MODEL}), "
    f"took {elapsed_time:.1f} seconds to execute.\n"
)

И получим:

 The image shows Machu Picchu, with lat:-13.16 and long:
 -72.54, located in Peru  and about 2,250 kilometers away
 from Santiago, Chile.

В блокноте 30-Function_Calling_with_images можно найти эксперименты с несколькими изображениями.

Теперь скачайте скрипт calc_distance_image.py из репозитория EdgeML-with-Raspberry-Pi и запустите его в терминале командой:

python calc_distance_image.py \
  /home/username/Documents/OLLAMA/image_test_3.jpg

Укажите полный путь к изображению Мачу-Пикчу в качестве аргумента. Мы получим тот же результат, что и раньше.

А как насчёт Парижа?

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

Методы оптимизации SLM

Большие языковые модели (LLM) произвели революцию в обработке естественного языка, но их развёртывание и оптимизация связаны с особыми сложностями. Одна из существенных проблем — склонность LLM (и тем более SLM) генерировать правдоподобно звучащую, но фактически неверную информацию. Это явление известно как галлюцинации: модель выдаёт содержимое, которое выглядит связным, но не опирается на истину или реальные факты.

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

Основные методы повышения производительности и эффективности LLM (и SLM): дообучение (fine-tuning), инженерия запросов (prompt engineering) и генерация с дополнением поиском (Retrieval-Augmented Generation, RAG).

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

• Инженерия запросов (prompt engineering) стоит на переднем крае оптимизации LLM. Тщательно составляя входные запросы, мы можем направить модель на более точные и релевантные ответы. Этот метод предполагает формулировку запросов, которые используют предобученные знания и возможности модели, часто включая примеры или конкретные инструкции, задающие нужный ответ.

• Генерация с дополнением поиском (Retrieval-Augmented Generation, RAG) — ещё один мощный подход к повышению производительности LLM. Метод сочетает обширные знания, заложенные в предобученной модели, со способностью получать и использовать внешнюю, актуальную информацию. Извлекая релевантные данные для поддержки процесса принятия решений моделью, RAG может существенно повысить точность и снизить вероятность генерации устаревших или ложных сведений.

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

Реализация RAG

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

Простой RAG-проект

Вот шаги для реализации базовой генерации с дополнением поиском (Retrieval Augmented Generation, RAG):

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

• Разбейте текст на фрагменты (chunks): нельзя хранить текст как один длинный поток из-за ограничений размера контекста и риска путаницы. Разбиение (чанкинг) означает деление текста на более мелкие части. Текст можно разбивать разными способами: по количеству символов, токенов, слов, абзацев или разделов. Фрагменты также можно перекрывать.

• Создайте эмбеддинги: эмбеддинги — это числовые представления текста, которые отражают его смысл. Чтобы создать эмбеддинг, каждый фрагмент текста пропускается через определённую модель эмбеддингов. Модель выдаёт вектор, длина которого зависит от используемой модели. Для этой задачи нужно загрузить из Ollama одну (или несколько) моделей эмбеддингов. Ниже приведены примеры моделей эмбеддингов, доступных в Ollama:

> Как правило, большие размеры эмбеддингов лучше передают тонкие нюансы входных данных. Однако их обработка требует больше вычислительных ресурсов, а большее число параметров должно увеличивать задержку (но и качество ответа).

• Сохраните фрагменты и эмбеддинги в векторной базе данных: нам нужен способ эффективно находить наиболее релевантные фрагменты текста для данного запроса, и здесь на помощь приходит векторная база данных. Мы будем использовать Chromadb — открытую векторную базу данных для задач ИИ, которая упрощает создание RAG, подключая знания, факты и навыки к LLM. Для каждого фрагмента хранятся и эмбеддинг, и исходный текст.

• Соберите запрос (prompt): когда появляется вопрос, мы создаём для него эмбеддинг и запрашиваем у векторной базы данных наиболее похожие фрагменты. Затем выбираем несколько лучших результатов и включаем их текст в запрос.

Цель RAG — предоставить модели наиболее релевантную информацию из наших документов, чтобы она могла генерировать более точные и содержательные ответы. Поэтому реализуем простой пример SLM, который опирается на набор фактов о пчёлах («Bee Facts»).

В окружении ollama выполните в терминале команду установки Chromadb:

pip install ollama chromadb

Загрузим модель эмбеддингов среднего размера nomic-embed-text:

ollama pull nomic-embed-text

Создадим рабочий каталог:

cd Documents/OLLAMA/
mkdir RAG-simple-bee
cd RAG-simple-bee/

Создадим новый блокнот Jupyter 40-RAG-simple-bee для экспериментов.

Импортируем нужные библиотеки:

import ollama
import chromadb
import time

Определим модели:

EMB_MODEL = "nomic-embed-text"
MODEL = "llama3.2:3B"

Сначала нужно создать базу знаний о пчёлах. Для этого собираем релевантные документы и преобразуем их в векторные эмбеддинги. Эти эмбеддинги сохраняются в векторной базе данных, что позволяет быстро выполнять поиск по сходству в дальнейшем. Введём «документы» — базу «фактов о пчёлах» в виде списка:

documents = [
    "Пчеловодство, также известное как апикультура, подразумевает \
    уход за пчелиными семьями, обычно в ульях, которым занимается человек.",
    "Самый распространённый вид пчёл, которых содержат люди, — \
    европейская медоносная пчела (Apis mellifera).",

    ...

    "В мире существует ещё около 20 000 видов пчёл.",
    "Только в Бразилии более 300 видов пчёл, и подавляющее большинство \
    из них, в отличие от западных медоносных пчёл, не жалит.",
    "В отчётах, написанных в 1577 году Гансом Стаденом, упоминаются три \
    местных вида пчёл, которых использовали коренные жители Бразилии.",
    "Коренные жители Бразилии использовали пчёл в медицинских и пищевых целях.",
    "Из отчёта Ганса Стадена: вероятные виды: mandaçaia (Melipona quadrifasciata), \
    mandaguari (Scaptotrigona postica) и jataí-amarela (Tetragonisca angustula)."
]

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

Теперь создадим векторную базу эмбеддингов bee_facts и сохраним в ней документы:

client = chromadb.Client()
collection = client.create_collection(name="bee_facts")

# Сохраняем каждый документ в векторной базе эмбеддингов
for i, d in enumerate(documents):
    response = ollama.embeddings(model=EMB_MODEL, prompt=d)
    embedding = response["embedding"]
    collection.add(
        ids=[str(i)], embeddings=[embedding], documents=[d]
    )

Теперь, когда «база знаний» создана, можно начинать запросы и извлекать из неё данные:

Запрос пользователя: процесс начинается, когда пользователь задаёт вопрос, например: «Сколько пчёл в семье? Кто откладывает яйца и в каком количестве? А как насчёт распространённых вредителей и болезней?»

prompt = "Сколько пчёл в семье? Кто откладывает яйца и в каком количестве? \
          А как насчёт распространённых вредителей и болезней?"

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

response = ollama.embeddings(prompt=prompt, model=EMB_MODEL)

Поиск релевантных документов: система ищет в базе знаний по эмбеддингу запроса наиболее релевантные документы (в данном случае 5 наиболее вероятных). Это делается поиском по сходству, который сравнивает эмбеддинг запроса с эмбеддингами документов в базе.

results = collection.query(
    query_embeddings=[response["embedding"]], n_results=5
)
data = results["documents"]

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

prompt = (
    f"Using this data: {data}. " f"Respond to this prompt: {prompt}"
)

Генерация ответа: дополненный запрос передаётся языковой модели, в данном случае llama3.2:3b. Модель использует этот обогащённый контекст, чтобы сформировать развёрнутый ответ. Параметры temperature, top_k и top_p задают степень случайности и качество генерируемого ответа.

output = ollama.generate(
  model=MODEL,
  prompt = (
      f"Using this data: {data}. "
      f"Respond to this prompt: {prompt}"
  ),

  options={
    "temperature": 0.0,
    "top_k":10,
    "top_p":0.5
  }
)

Передача ответа: наконец, система возвращает пользователю сгенерированный ответ.

print(output["response"])

Based on the provided data, here are the answers to your \
questions:

1. How many bees are in a colony?
A typical bee colony can contain between 20,000 and 80,000 bees.

2. Who lays eggs and how much?
The queen bee lays up to 2,000 eggs per day during peak seasons.

3. What about common pests and diseases?
Common pests and diseases that affect bees include varroa \
mites, hive beetles, and foulbrood.

Создадим функцию, которая поможет отвечать на новые вопросы:

def rag_bees(prompt, n_results=5, temp=0.0, top_k=10, top_p=0.5):
    start_time = time.perf_counter()  # Запускаем таймер

    # Создаём эмбеддинг запроса и получаем релевантные данные
    response = ollama.embeddings(
      prompt=prompt,
      model=EMB_MODEL
    )

    results = collection.query(
      query_embeddings=[response["embedding"]],
      n_results=n_results
    )
    data = results['documents']

    # Генерируем ответ, объединяя запрос и полученные данные
    output = ollama.generate(
      model=MODEL,
      prompt = (
         f"Using this data: {data}. "
         f"Respond to this prompt: {prompt}"
      ),

      options={
        "temperature": temp,
        "top_k": top_k,
        "top_p": top_p
      }
    )

    print(output['response'])

    end_time = time.perf_counter()  # Останавливаем таймер
    elapsed_time = round(
       (end_time - start_time), 1
    )  # Вычисляем затраченное время

    print(
       f"\n[INFO] ==> The code for model: {MODEL}, "
       f"took {elapsed_time}s to generate the answer.\n"
    )

Теперь можно формулировать запросы и вызывать функцию:

prompt = "Есть ли в Бразилии пчёлы?"
rag_bees(prompt)

Yes, bees are found in Brazil. According to the data, Brazil \
has more than 300 different bee species, and indigenous people \
in Brazil used bees for medicine and food purposes. \
Additionally, reports from 1577 mention three native bees \
used by indigenous people in Brazil.

 [INFO] ==> The code for model: llama3.2:3b, took 22.7s to \
 generate the answer.

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

prompt = "Existem abelhas no Brazil?"
rag_bees(prompt)

Sim, existem abelhas no Brasil! De acordo com o relato de Hans \
Staden, há três espécies de abelhas nativas do Brasil que \
foram mencionadas: mandaçaia (Melipona quadrifasciata), \
mandaguari (Scaptotrigona postica) e jataí-amarela \
(Tetragonisca angustula). Além disso, o Brasil é conhecido \
por ter mais de 300 espécies diferentes de abelhas, a \
maioria das quais não é agressiva e não põe veneno.

 [INFO] ==> The code for model: llama3.2:3b, took 54.6s to \
            generate the answer.

Дальнейшие шаги

Протестированные небольшие языковые модели хорошо работают на периферии и с текстом, и с изображениями, однако при работе с изображениями задержка оказалась высокой. Сочетание специализированных моделей может дать лучшие результаты. Например, в реальных задачах модель обнаружения объектов (такая как YOLO) может получить общее описание и количество объектов на изображении. Затем это описание передаётся LLM, которая помогает извлечь ключевые выводы и определить действия.

Avi Baum, технический директор (CTO) Hailo, говорит:

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

Итоги

Эта лабораторная работа показала, как Raspberry Pi 5 можно превратить в мощный ИИ-узел, способный запускать большие языковые модели (LLM) для анализа данных на месте и в реальном времени с помощью Ollama и Python. Универсальность и мощность Raspberry Pi в сочетании с возможностями лёгких LLM, таких как Llama 3.2 и LLaVa-Phi-3-mini, делают её отличной платформой для периферийных вычислений.

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

1. Умный дом:

• Интегрируйте SLM, чтобы интерпретировать голосовые команды или анализировать данные датчиков для интеллектуальной автоматизации дома. Это может включать мониторинг и управление бытовыми устройствами в реальном времени, системами безопасности и управлением энергопотреблением, всё с локальной обработкой без облачных сервисов.

2. Сбор и анализ данных в полевых условиях:

• Развёртывайте SLM на Raspberry Pi в удалённых или мобильных установках для сбора и анализа данных в реальном времени. Это может применяться в сельском хозяйстве для мониторинга состояния посевов, в экологических исследованиях для отслеживания диких животных или при ликвидации последствий катастроф для оценки обстановки и управления ресурсами.

3. Образовательные инструменты:

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

4. Медицинские приложения:

• Используйте SLM для медицинской диагностики и мониторинга пациентов. Они могут анализировать симптомы в реальном времени и предлагать возможные варианты лечения. Это можно интегрировать в платформы телемедицины или портативные медицинские устройства.

5. Локальная бизнес-аналитика:

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

6. Промышленный интернет вещей (IIoT):

• Интегрируйте SLM в промышленные системы IoT для предиктивного обслуживания, контроля качества и оптимизации процессов. Raspberry Pi может служить локальным блоком обработки данных, снижая задержки и повышая надёжность автоматизированных систем.

7. Автономные транспортные средства:

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

8. Культурное наследие и туризм:

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

9. Художественные и творческие проекты:

• Используйте SLM для анализа и генерации творческого контента: музыки, искусства и литературы. Это может стимулировать инновационные проекты в креативных индустриях и создавать уникальный интерактивный опыт на выставках и представлениях.

10. Персонализированные вспомогательные технологии:

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

Ресурсы

• Блокнот 10-Ollama_Python_Library
• Блокнот 20-Ollama_Function_Calling
• Блокнот 30-Function_Calling_with_images
• Блокнот 40-RAG-simple-bee
• Скрипт calc_distance_image на Python

Обнаружение объектов

Промпт DALL·E: обложка для главы «Обнаружение объектов» руководства по Raspberry Pi, выполненная в том же винтажном стиле лаборатории электроники 1950-х, что и предыдущие обложки. На переднем плане на верстаке — колёса и кубики, похожие на предоставленные пользователем. Raspberry Pi с подключённым модулем камеры снимает эти объекты. Сцену окружают классические лабораторные инструменты: паяльники, резисторы и провода. На фоне лаборатории — старинное оборудование: осциллографы и ламповые радиоприёмники, сохраняющие детальное и ностальгическое ощущение эпохи. Логотипов и текста быть не должно.