Машинное зрение на Raspberry Pi 4: обучение YOLOv8 и работа с Raspberry AI Camera

Архитектура проекта и подготовка Raspberry Pi 4 и AI Camera

Зачем нужна эта статья

Эта статья задаёт скелет всего курса: какую архитектуру проекта мы строим, какие роли у Raspberry Pi 4 и Raspberry Pi AI Camera, и как подготовить систему так, чтобы в следующих статьях вы без боли:

собирали датасет и обучали YOLOv8

переносили модель на Raspberry Pi

загружали модель в AI Camera (если выбран сценарий с инференсом на камере)

писали Python-код, который реагирует на распознанные объекты

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

Общая архитектура решения

В практических проектах на Raspberry Pi почти всегда есть две вычислительные зоны:

зона обучения (обычно ПК/сервер, потому что обучение требует много ресурсов)

зона применения (Raspberry Pi + камера, работа в реальном времени)

Raspberry Pi 4 подходит для инференса лёгких моделей и для “склейки” системы (камера, логика, сеть, управление), но обучение YOLOv8 обычно выполняют на более мощной машине.

!Общая схема: обучение отдельно, применение на Raspberry Pi, два варианта инференса

Два сценария инференса: на Raspberry Pi или на AI Camera

Важно сразу выбрать, как вы планируете выполнять инференс (это влияет на зависимости и формат модели).

Инференс на Raspberry Pi 4

Raspberry Pi получает кадры с камеры и запускает модель в Python.

Плюсы:

проще экспериментировать (Python, Ultralytics)

гибче постобработка (любой код, любые библиотеки)

Минусы:

производительность ограничена CPU (на Raspberry Pi 4 нет мощного GPU для DL)

Инференс на Raspberry Pi AI Camera

Часть вычислений выполняется на самой камере (в зависимости от возможностей конкретной модели/прошивки).

Плюсы:

меньше нагрузка на Raspberry Pi

потенциально выше скорость и стабильнее задержки

Минусы:

обычно строже требования к формату модели и пайплайну экспорта

некоторые эксперименты проще делать сначала в варианте “инференс на Raspberry Pi”, а потом переносить

В этом курсе мы построим проект так, чтобы поддержать оба варианта: сначала поднимем базовый захват изображения и окружение на Raspberry Pi, затем добавим YOLOv8, а дальше перейдём к экспорту и запуску в выбранном режиме.

Минимальный состав оборудования

| Компонент | Зачем нужен | Примечания | |---|---|---| | Raspberry Pi 4 (желательно 4–8 GB) | управление камерой, инференс/логика, сеть | чем больше RAM, тем комфортнее разработка | | microSD (32–128 GB) | ОС, код, модели | лучше A1/A2, надёжный бренд | | Блок питания USB-C 5V 3A | стабильность под нагрузкой | нестабильное питание часто ломает всё | | Raspberry Pi AI Camera | источник изображения, возможный инференс на камере | подключение через CSI | | CSI-шлейф | соединение камеры и Raspberry Pi | подключать при выключенном питании | | Охлаждение (радиатор/вентилятор) | снижение троттлинга | важно при длительной нагрузке |

Базовая структура проекта

С самого начала держите проект так, чтобы обучение, модели и код на Raspberry Pi не смешивались в одну папку.

Рекомендуемая структура репозитория:

README.md — инструкции запуска

requirements.txt — Python-зависимости (если используете)

src/ — основной код приложения

src/camera/ — захват кадров, работа с libcamera

src/inference/ — обёртки инференса (YOLOv8 на Pi или результаты с AI Camera)

src/logic/ — бизнес-логика (что делать при обнаружении объектов)

models/ — модели для инференса (веса, экспортированные форматы)

data/ — тестовые изображения/видео (не огромные датасеты)

scripts/ — утилиты (конвертация, проверка камеры, замеры FPS)

> Бизнес-логика — это код, который принимает решение: например, “если обнаружен человек в зоне — включить реле на GPIO и отправить уведомление”.

Подготовка Raspberry Pi OS

Выбор ОС

Рекомендуется ставить актуальную 64-битную Raspberry Pi OS (особенно если вы планируете современные Python-библиотеки).

Raspberry Pi OS (64-bit)

способ установки: Raspberry Pi Imager

Официальное руководство по установке:

Getting started with Raspberry Pi

Прошивка microSD через Raspberry Pi Imager

В Raspberry Pi Imager удобно сразу включить базовые настройки:

включить SSH

задать имя пользователя и пароль

настроить Wi‑Fi (если нужно)

задать hostname (например, rpi-vision)

Первые действия после первого запуска

Обновите систему:

Установите базовые утилиты:

Подключение Raspberry Pi AI Camera (аппаратная часть)

Как подключать CSI-камеру правильно

CSI — это разъём для камер (шлейф), который подключается напрямую к Raspberry Pi.

Правила подключения:

выключите Raspberry Pi и отключите питание

аккуратно поднимите фиксатор CSI-разъёма

вставьте шлейф правильной стороной (контакты должны совпасть с контактами разъёма)

опустите фиксатор

закрепите камеру так, чтобы шлейф не “гулял”

> Если камера периодически “отваливается”, очень часто причина — плохой контакт шлейфа или недостаточное питание.

Проверка, что камера видится системой (libcamera / rpicam)

На современных версиях Raspberry Pi OS камера работает через стек libcamera. Проверять лучше штатными утилитами.

Официальная документация по программному стеку камеры:

Camera software

Быстрый тест камеры

Попробуйте вывести тестовое изображение:

Сделайте снимок:

Запишите короткое видео:

Если команды не найдены, установите приложения:

Подготовка Python-окружения под проект

Чтобы зависимости проекта не конфликтовали с системными, используйте виртуальное окружение (venv).

Виртуальное окружение (venv) — это отдельная папка с Python и установленными пакетами, привязанными только к проекту.

Создание venv

В папке проекта:

Установка базовых зависимостей

На Raspberry Pi иногда удобнее поставить OpenCV из репозиториев (готовая сборка), а venv создать с доступом к системным пакетам.

Вариант А (удобно для Raspberry Pi): системный OpenCV + venv с доступом к системным пакетам

Далее ставим Ultralytics (YOLOv8):

Ultralytics documentation

Проверка:

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

Проверка производительности и стабильности (минимум перед стартом)

Рекомендуемые быстрые проверки:

температура и троттлинг (особенно если планируете инференс на Raspberry Pi)

стабильность питания (нет самопроизвольных ребутов)

стабильный захват кадров с камеры (нет ошибок libcamera)

Практический минимум:

Если vcgencmd отсутствует, установите пакет утилит (название может отличаться по версии ОС), либо пропустите этот шаг и вернитесь к нему позже.

Итог: что должно быть готово перед следующей статьёй

К концу этой статьи у вас должно быть:

Raspberry Pi OS обновлена

Raspberry Pi AI Camera подключена по CSI

команды rpicam-hello и rpicam-still работают

создано Python venv

установлен пакет ultralytics

создана папка проекта со структурой, в которой будет удобно развивать код

Что будет дальше

В следующей статье мы перейдём к практической части пайплайна: как организовать сбор данных и подготовку датасета под YOLOv8 (структура, разметка, базовые проверки качества), чтобы обучение было предсказуемым, а перенос модели на Raspberry Pi и AI Camera — не превращался в серию случайных исправлений.

Python-пайплайн: захват кадров, предобработка и тестовый инференс

Зачем нужна эта статья

В прошлой статье мы подготовили Raspberry Pi OS, подключили Raspberry Pi AI Camera через CSI, проверили rpicam- и подняли Python-окружение с ultralytics. Теперь соберём рабочий Python-пайплайн*, который станет основой всех следующих шагов курса:

захват кадров с Raspberry Pi AI Camera в Python

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

тестовый инференс YOLOv8 на Raspberry Pi 4

единый формат выхода (детекции), чтобы дальше удобно писать бизнес-логику

> Пайплайн — это последовательность этапов обработки: камера → кадр → подготовка → модель → результаты → действия.

!Схема полного Python-пайплайна от камеры до бизнес-логики

Что должно быть готово перед стартом

Raspberry Pi OS обновлена, камера работает через rpicam-hello

создано venv (как в прошлой статье)

установлен ultralytics

установлен OpenCV (например, sudo apt install -y python3-opencv)

Полезные источники:

Документация Raspberry Pi по камерам и libcamera

Репозиторий Picamera2

Документация Ultralytics YOLO

Почему для камеры лучше Picamera2, а не OpenCV VideoCapture

На Raspberry Pi OS современный стек камеры — libcamera. Самый практичный способ получать кадры в Python — библиотека Picamera2 (она “родная” для libcamera).

OpenCV cv2.VideoCapture иногда работает через V4L2-совместимость, но:

настройки (разрешение, формат, буферы) часто менее предсказуемы

сложнее получить стабильную производительность

на CSI-камерах типично удобнее и надёжнее Picamera2

В этом курсе базовый пайплайн будет построен на Picamera2.

Установка Picamera2

На Raspberry Pi OS Picamera2 обычно ставится через apt:

Проверка импорта (в вашем venv с --system-site-packages):

Если импорт не работает, чаще всего причина одна из двух:

venv создан без --system-site-packages (тогда Python из venv не видит пакеты, установленные через apt)

вы запускаете не тот Python (проверьте which python и что активирован source .venv/bin/activate)

Стандартизируем формат кадра: BGR как “внутренний контракт”

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

Внутренний контракт кадра в проекте:

тип: numpy.ndarray

форма: H x W x 3

порядок каналов: BGR

тип данных: uint8

Почему BGR:

OpenCV по умолчанию работает в BGR

Ultralytics обычно получает изображения из OpenCV-стека (и ожидает совместимый формат на входе в типичных сценариях)

> Важно: камера может отдавать RGB, YUV и другие форматы. Мы приводим всё к BGR, чтобы дальше код не содержал случайных конвертаций.

Минимальный модуль захвата кадра (Picamera2)

Добавим файл src/camera/picamera2_source.py.

Что здесь происходит:

create_preview_configuration(...) создаёт конфигурацию потока

format: BGR888 задаёт формат, совместимый с OpenCV

capture_array("main") возвращает numpy-массив

Предобработка: что мы делаем и зачем

Предобработка — это любые операции, которые приводят изображение к удобному для модели и логики виду.

Минимально полезный набор предобработки для старта:

проверка типа и формы кадра (чтобы быстро находить ошибки)

уменьшение разрешения для ускорения инференса

опционально ROI (область интереса), если вам не нужен весь кадр

Добавим файл src/vision/preprocess.py.

Практический смысл:

ensure_bgr_u8 быстро ловит ситуации “не тот формат/не тот dtype”

resize_keep_aspect позволяет уменьшить кадр без искажений

crop_roi пригодится, когда вы будете оптимизировать скорость или отсекать лишнюю зону

Тестовый инференс YOLOv8 на одном кадре

Сделаем первый “сквозной” тест: захватили один кадр → прогнали YOLOv8 → напечатали найденные объекты.

Создайте scripts/test_single_frame.py.

Запуск из корня проекта:

Что вы должны увидеть:

модель автоматически скачает веса yolov8n.pt (нужен интернет)

в консоль выведутся классы (например, person, bottle) и рамки

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

Непрерывный пайплайн: кадры → инференс → результат

Теперь соберём “черновой runtime-цикл”, который дальше будет расширяться логикой.

Сделаем файл src/inference/yolo8_ultralytics.py.

Определим простой “контракт детекций” для бизнес-логики: список словарей.

Добавим src/inference/detections.py.

Теперь — основной цикл src/app.py.

Запуск:

Как понимать скорость: FPS и задержка

В реальном времени важно понимать два параметра:

FPS — сколько кадров в секунду система обрабатывает

latency (задержка) — сколько времени проходит от момента “кадр появился” до момента “решение готово”

В простом цикле выше мы грубо оцениваем FPS по количеству итераций за интервал времени.

Если FPS низкий, самые рабочие рычаги на Raspberry Pi 4:

уменьшить imgsz (например, 640 → 416 или 320)

использовать более лёгкие веса (yolov8n.pt легче, чем yolov8s.pt)

уменьшить разрешение кадра, подаваемого в модель

делать инференс не на каждом кадре (например, каждый 2-й или 3-й), если логика это позволяет

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

Типовые проблемы и быстрые диагностики

Picamera2 не импортируется

проверьте установку python3-picamera2

проверьте, что venv создан с --system-site-packages

Кадр “не того цвета”

убедитесь, что вы используете format: BGR888 в конфигурации Picamera2

не делайте лишних cv2.cvtColor, пока не зафиксировали единый контракт BGR

Модель работает, но очень медленно

попробуйте imgsz=320

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

проверьте температуру, чтобы исключить троттлинг

Итог: что у вас должно получиться

К концу статьи у вас есть:

модуль захвата кадров с Raspberry Pi AI Camera через Picamera2

минимальная предобработка и единый “контракт” кадра (BGR uint8)

тест инференса YOLOv8 на одном кадре

непрерывный пайплайн, который выдаёт детекции в простом формате

Что будет дальше

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

данные и обучение: как собрать и разметить датасет, обучить YOLOv8 под вашу задачу и получить стабильное качество

деплой и интеграция: как экспортировать модель, ускорять инференс и, при необходимости, переносить часть инференса на AI Camera, а также как писать бизнес-логику, реагирующую на детекции

Датасет и разметка: классы, формат YOLO, аугментации и контроль качества

Зачем нужна эта статья

В предыдущих статьях вы:

подготовили Raspberry Pi 4 и Raspberry Pi AI Camera

собрали рабочий Python-пайплайн захвата кадров и тестового инференса YOLOv8

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

В этой статье вы разберёте:

как формулировать классы и правила разметки

как устроен формат разметки YOLO (Ultralytics)

как собрать данные под вашу задачу на Raspberry Pi

какие аугментации действительно полезны, а какие ломают задачу

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

!Общий конвейер данных от камеры до обученной модели

Сначала определяем задачу и классы

Что такое класс

Класс — это категория объекта, которую модель должна распознавать (например, person, bottle, helmet).

Хорошие правила выбора классов

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

Начинайте с малого: 1–3 класса проще довести до стабильного качества.

Избегайте классов, которые различимы только по неуловимым признакам (особенно на маленьких объектах).

Пишем спецификацию разметки (это обязательно)

Спецификация — это короткий документ с правилами, по которым вы размечаете.

Минимум, который стоит определить:

Что считается объектом класса (точные примеры).

Что не считается объектом класса (контрпримеры).

Как рисовать рамку:

- включать ли тени - включать ли частичные части (например, “видна половина объекта”) - как размечать сильные перекрытия

Минимальный размер объекта, который вы вообще размечаете (например, “меньше 16×16 пикселей не размечаем”).

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

Сбор данных: как получить изображения под реальную среду

Почему нельзя полагаться только на “красивые” изображения

Модель будет работать в условиях:

вашего освещения

вашей камеры

вашего расстояния до объектов

ваших фонов

Поэтому данные должны отражать реальность.

Что обязательно собрать

Разные условия света: дневной, искусственный, слабый.

Разные фоны: пустой фон, загруженный фон.

Разные расстояния и масштабы объекта.

Разные ракурсы и частичные перекрытия.

Негативные кадры: сцены, где похожие объекты отсутствуют (это помогает снизить ложные срабатывания).

Практический сбор на Raspberry Pi

Вы уже умеете получать кадры через Picamera2. Для датасета обычно делают так:

записывают короткие видео

нарезают видео на кадры (например, 2–5 кадров в секунду)

размечают выбранные кадры

Почему видео удобно:

легче снять много сцен

проще поймать разные состояния объекта

Инструменты для захвата видео/кадров:

rpicam-vid и rpicam-still из rpicam-apps

ваш Python-скрипт на Picamera2 (если нужна привязка к событиям)

Документация по камере:

Camera software (Raspberry Pi)

Формат датасета Ultralytics YOLO

Ultralytics YOLOv8 ожидает стандартную структуру папок и разметку в формате YOLO.

Официальная документация формата и датасетов:

Ultralytics Datasets

Структура папок

Типичная структура:

datasets/your_dataset/images/train/

datasets/your_dataset/images/val/

datasets/your_dataset/images/test/ (опционально)

datasets/your_dataset/labels/train/

datasets/your_dataset/labels/val/

datasets/your_dataset/labels/test/ (опционально)

Правило соответствия:

на каждое изображение images/.../abc.jpg должен быть файл разметки labels/.../abc.txt

Формат одной строки в YOLO-разметке

Каждый объект в кадре — это одна строка в *.txt:

class_id x_center y_center width height

Где:

class_id — номер класса (целое число, начинается с 0)

x_center — координата центра рамки по X

y_center — координата центра рамки по Y

width — ширина рамки

height — высота рамки

Особенность YOLO-формата:

x_center, y_center, width, height нормированы в диапазон от 0 до 1

нормирование идёт относительно размеров изображения: ширины и высоты

Пример (один объект):

Это означает:

класс 0

центр рамки примерно в середине кадра

ширина рамки занимает около 21% ширины изображения

высота рамки занимает около 33% высоты изображения

Файл конфигурации датасета data.yaml

Ultralytics использует YAML-файл, где указаны пути и имена классов.

Пример datasets/your_dataset/data.yaml:

Важно:

номера в names должны совпадать с class_id в ваших *.txt

порядок классов нельзя “случайно менять” между версиями датасета, иначе модель начнёт путать классы

Чем размечать: инструменты

Выбор инструмента разметки — это баланс удобства и контроля.

Популярные варианты:

CVAT — мощно для командной разметки, можно поднимать локально

LabelImg — простой десктопный инструмент

Roboflow — платформа с разметкой и экспортами (удобно, но учитывайте хранение данных)

Критерии выбора:

экспорт в YOLO-формат

скорость разметки

возможность быстро исправлять ошибки

Разметка: практические правила, которые дают прирост качества

Рамка должна быть “плотной”

Рамка должна покрывать объект без лишнего фона.

Систематически “слишком большие рамки” ухудшают локализацию.

Одинаковый стиль на всём датасете

Если вы размечаете частично видимые объекты — размечайте их всегда по одному правилу.

Если вы не размечаете “слишком маленькие” объекты — не размечайте их нигде.

Негативные изображения

Для YOLO детектор обучается на изображениях даже без объектов целевых классов.

Как это выглядит в структуре:

изображение есть

файл .txt либо пустой, либо отсутствует (на практике удобнее создавать пустой .txt, чтобы пайплайн был стабильнее)

Разбиение на train/val/test без утечек

Разбиение нужно, чтобы честно оценивать качество.

train — на этом модель учится

val — на этом вы подбираете параметры и сравниваете версии

test — финальная “честная проверка” (опционально, но полезно)

Главная ошибка: утечка почти одинаковых кадров

Если вы нарезали видео на кадры, соседние кадры очень похожи. Если часть уйдёт в train, а часть — в val, качество на val будет завышено.

Практическое правило:

делите по сценам, а не по отдельным кадрам

например: “видео_01 целиком в train, видео_02 целиком в val”

Аугментации: что это и как их использовать

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

В YOLOv8 многие аугментации включены по умолчанию и применяются на лету во время обучения.

Документация по режимам обучения и настройкам:

Ultralytics Training

Полезные аугментации для камеры в реальной среде

изменение яркости и контраста (помогает при разном освещении)

лёгкий поворот и наклон (если камера может быть установлена не идеально)

масштабирование и сдвиг (если объект может быть ближе/дальше)

лёгкий blur (если возможна тряска/смаз)

шум (если в плохом свете появляются артефакты)

Опасные аугментации, которые часто ломают задачу

слишком сильные повороты, если объект в жизни так не встречается

агрессивные crop, которые отрезают половину объекта, если вы такие случаи не размечали

сильное изменение цветов, если цвет — важный признак класса

Главное правило аугментаций

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

Контроль качества датасета: чек-лист

Ниже — практические проверки, которые экономят часы обучения.

Проверка соответствия файлов

для каждого изображения есть разметка (даже пустая)

нет “лишних” txt без изображений

Проверка диапазонов и формата

class_id в пределах списка классов

x_center, y_center, width, height в диапазоне 0..1

width > 0, height > 0

Проверка распределения классов

Плохо, когда:

один класс представлен тысячами объектов, другой — десятками

почти все объекты слишком маленькие или слишком большие

Проверка качества рамок на выборке

Сделайте ручной просмотр хотя бы 50–200 случайных изображений:

нет ли систематического смещения рамок

не пропущены ли очевидные объекты

не размечены ли лишние объекты (ошибочные классы)

Проверка “трудных” сцен

Отдельно посмотрите:

плохое освещение

сильные перекрытия

мелкие объекты

задний фон, который похож на целевой объект

Мини-скрипт валидации YOLO-разметки

Этот скрипт не доказывает, что разметка хорошая, но быстро ловит “поломанный формат”.

Создайте scripts/validate_yolo_labels.py:

Как использовать:

положите датасет в datasets/your_dataset/

поправьте num_classes

запустите python scripts/validate_yolo_labels.py

Итог: что должно быть готово перед обучением

Перед тем как переходить к обучению YOLOv8, убедитесь, что у вас есть:

список классов и спецификация разметки

изображения, отражающие реальную сцену с Raspberry Pi AI Camera

разметка в формате YOLO

разбиение на train/val (и опционально test) без утечек

базовая проверка качества разметки (хотя бы ручной просмотр + форматная валидация)

Что будет дальше

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

Обучение YOLOv8: настройки, валидация, метрики и улучшение качества

Зачем нужна эта статья

До этого вы:

подготовили Raspberry Pi 4 и Raspberry Pi AI Camera

собрали Python-пайплайн захвата кадров и тестового инференса YOLOv8 на Raspberry Pi

подготовили датасет и разметку в формате YOLO

Теперь нужно получить ваши веса модели (например, best.pt), чтобы затем перенести их в пайплайн инференса на Raspberry Pi и перейти к сценариям деплоя (включая вариант с AI Camera, если вы его выберете позднее).

Эта статья даёт практическую схему обучения YOLOv8:

как запустить обучение на ПК/сервере

какие настройки влияют на качество и скорость

как читать метрики и логи

как валидировать результат и находить проблемы в датасете

как улучшать качество системно, а не “на удачу”

!Диаграмма полного цикла: датасет → обучение → валидация → веса модели и итерации улучшения

Где обучать: почему не на Raspberry Pi

Raspberry Pi 4 годится для инференса и интеграции (камера, логика, GPIO, сеть), но полноценное обучение YOLOv8 на CPU Raspberry Pi будет очень медленным.

Практическая схема курса:

обучение: ПК/сервер (желательно с NVIDIA GPU)

применение: Raspberry Pi 4 + AI Camera

Если у вас нет GPU, вы всё равно можете обучать на CPU, но:

уменьшайте imgsz

используйте небольшие модели (yolov8n, yolov8s)

рассчитывайте на часы, а не минуты

Подготовка окружения для обучения

Рекомендуется обучать в отдельном виртуальном окружении.

Минимальные шаги:

Проверка:

Документация:

Ultralytics YOLO Docs

Ultralytics Train mode

Быстрый контроль датасета перед обучением

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

data.yaml указывает на правильный path и папки train/val

классы в names совпадают с class_id в разметке

нет утечки данных (похожие кадры из одного видео не смешаны между train и val)

Если вы использовали скрипт проверки формата разметки из прошлой статьи, вы уже закрыли часть типовых ошибок.

Первый запуск обучения (базовый, “правильный минимум”)

YOLOv8 удобно запускать через CLI Ultralytics.

Пример команды:

Пояснения ключевых параметров:

model=yolov8n.pt — старт с предобученных весов (transfer learning). Это почти всегда лучше, чем обучать “с нуля”.

data=.../data.yaml — ваш датасет.

epochs=50 — сколько проходов по обучающей выборке сделать.

imgsz=640 — размер изображения, на котором обучается модель.

batch=16 — размер батча (сколько изображений за один шаг оптимизации).

device=0 — первая GPU. Если GPU нет, используйте device=cpu.

Результаты обучения сохраняются в папке вида:

runs/detect/train/

Там обычно лежат:

weights/best.pt — лучшие веса по качеству на val

weights/last.pt — последние веса на последней эпохе

графики и логи (в том числе results.png)

Что именно происходит во время обучения

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

Во время обучения модель итеративно подстраивает свои параметры так, чтобы:

находить объекты нужных классов

ставить рамки ближе к разметке

снижать ошибки на train, но при этом не “зазубривать” датасет

При каждом прогоне валидации (на val) вы получаете метрики качества. По ним выбирается best.pt.

Валидация после обучения: отдельный запуск

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

Пример:

Документация:

Ultralytics Val mode

Основные метрики детектора и как их читать

Ultralytics выводит набор метрик. Для практики важно понимать смысл трёх групп.

Precision и Recall

Precision (точность) — “если модель сказала, что объект есть, насколько часто она права”.

Recall (полнота) — “из всех реальных объектов, сколько модель нашла”.

Практическая интерпретация:

высокая precision и низкая recall: модель “боится” детектировать, часто пропускает

низкая precision и высокая recall: модель “стреляет во всё”, много ложных срабатываний

На precision/recall сильно влияет порог уверенности conf при инференсе. Поэтому:

метрики валидации полезны для сравнения версий модели

но пороги conf и iou вы всё равно подбираете под задачу отдельно

mAP (mean Average Precision)

На практике чаще всего ориентируются на mAP50-95.

mAP50 — качество при более “мягком” требовании к совпадению рамок.

mAP50-95 — качество в среднем по диапазону требований, метрика строже и честнее.

Полезное правило:

если mAP50 высокий, а mAP50-95 заметно ниже, модель находит объекты, но рамки “неточные”

Confusion matrix и ошибки по классам

Если классов больше одного, обязательно смотрите:

какие классы путаются

есть ли класс, который почти всегда пропускается

Обычно это не “магия модели”, а проблема данных:

неоднозначные классы

непоследовательная разметка

сильный дисбаланс (одного класса мало)

Типовые симптомы и их причины

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

| Симптом | Вероятная причина | Что делать | |---|---|---| | Хорошо на train, плохо на val | переобучение, утечка похожих кадров, слабое разнообразие | исправить split “по сценам”, добавить вариативность, уменьшить модель, усилить регуляризацию через аугментации | | Плохие рамки (модель находит объект, но box “гуляет”) | неточный стиль разметки, слишком большие/маленькие рамки, маленький imgsz | выровнять стиль разметки, поднять imgsz, проверить качество боксов вручную | | Пропускает дальние/маленькие объекты | мало примеров маленьких объектов, низкое разрешение | добавить такие сцены, поднять imgsz, снять ближе, изменить постановку задачи | | Ложные срабатывания на фон | нет негативных примеров, фон похож на объект | добавить негативные кадры, расширить разнообразие фона | | Путает два класса | классы визуально близки или правила разметки размыты | переписать спецификацию разметки, объединить классы или добавить отличающие примеры |

Настройки обучения, которые чаще всего реально влияют

В YOLOv8 много параметров, но в проектах под Raspberry Pi обычно важны следующие.

Выбор размера модели

Меньше модель — быстрее инференс на Raspberry Pi, но потенциально хуже качество.

Практический ориентир:

yolov8n — старт по умолчанию для Raspberry Pi

yolov8s — если качество не хватает и вы готовы к падению FPS

Документация по моделям:

Ultralytics YOLO Models

imgsz

imgsz влияет на:

качество на маленьких объектах

скорость обучения

скорость инференса

Практика:

стартуйте с imgsz=640

если не хватает скорости, пробуйте 416 или 320

если важны мелкие объекты, иногда нужно imgsz=768 или 896, но это дороже

epochs

Слишком мало эпох — модель не успевает адаптироваться. Слишком много — растёт риск переобучения.

Практика:

старт: 50–100 эпох

дальше ориентируйтесь на метрики val и стабильность кривых

batch

batch зависит от памяти GPU.

Практика:

увеличивайте batch, пока не упираетесь в память

если GPU нет, на CPU ставьте небольшой batch (например, 4–16)

Аугментации

В YOLOv8 аугментации включены по умолчанию. Они помогают обобщать, но могут ломать задачу, если “перегнуть”.

Правило из прошлой статьи сохраняется:

аугментации должны имитировать реальность вашей сцены

Если у вас камера стоит стационарно и объект всегда “ровный”, агрессивные повороты могут ухудшить качество.

Практический цикл улучшения качества (как работать итерациями)

Хороший результат обычно получается не с первого запуска. Рабочая стратегия — короткие итерации.

Сделайте первый baseline-тренинг (например, yolov8n, imgsz=640, epochs=50).

Посмотрите метрики val и визуальные примеры предсказаний.

Составьте список ошибок по категориям.

Примите решение: проблема в данных или в настройках.

Внесите одно изменение за итерацию и повторите обучение.

Как смотреть предсказания на изображениях

Для контроля качества важно не только число mAP, но и визуальная проверка.

Пример предикта на папке валидации:

Документация:

Ultralytics Predict mode

Что смотреть глазами:

систематические промахи рамки (например, всегда смещена вправо)

пропуски в конкретных условиях (плохой свет, дальний план)

ложные срабатывания на конкретных текстурах

Самый частый “секрет” качества: исправление датасета

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

Приоритет улучшений часто такой:

исправить ошибки разметки и привести к единому стилю

добавить недостающие сценарии (свет, фон, расстояние)

добавить негативные кадры

только потом “тюнить” параметры обучения

Как готовить результат к переносу на Raspberry Pi

В контексте курса ваша цель — получить веса, которые потом можно подставить в Python-пайплайн на Raspberry Pi.

Минимум, что нужно сохранить и зафиксировать:

файл весов best.pt

точную версию датасета (хэш/архив/тэг в git, чтобы можно было повторить)

файл data.yaml и список классов

команду обучения (как минимум параметры model, imgsz, epochs, batch)

В следующем шаге курса (деплой) вы:

перенесёте best.pt на Raspberry Pi

проверите инференс в вашем src/app.py

начнёте оптимизировать скорость и формат модели под целевое устройство

Итог

К этому моменту вы умеете:

запускать обучение YOLOv8 на своём датасете

отличать best.pt от last.pt и понимать, почему это важно

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

читать ключевые метрики (precision, recall, mAP) и связывать их с ошибками

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

Развертывание на Raspberry: экспорт, ускорение и логика работы с объектами

Зачем нужна эта статья

На предыдущих шагах вы:

подняли Raspberry Pi 4 и Raspberry Pi AI Camera и проверили захват кадра

собрали Python-пайплайн (Picamera2 → предобработка → YOLOv8 → детекции)

подготовили датасет и обучили YOLOv8, получив best.pt

Теперь нужно довести решение до прикладного состояния на Raspberry Pi:

перенести и подключить ваши веса (best.pt) вместо yolov8n.pt

понять, в каких форматах модель можно экспортировать и когда это имеет смысл

ускорить инференс на Raspberry Pi (без “магии”, через системные рычаги)

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

!Общая карта пути от обученной модели до работающей системы на Raspberry Pi

Что потребуется

Минимум для базового варианта (инференс на Raspberry Pi):

Raspberry Pi 4 с рабочей камерой через Picamera2

ваш файл весов best.pt

установленный ultralytics (как в первых статьях)

Полезные официальные источники:

Документация Ultralytics YOLO

Экспорт моделей Ultralytics

Документация Picamera2

Базовое развертывание: используем best.pt на Raspberry Pi

Шаг 1: перенос весов на Raspberry Pi

Проще всего использовать scp (если Raspberry Pi доступна по SSH).

Пример с ПК:

Если rpi-vision.local не резолвится, используйте IP-адрес Raspberry Pi.

Шаг 2: подключаем веса в вашем приложении

В прошлой статье у вас был класс YoloV8Ultralytics, который принимает weights_path.

Замените yolov8n.pt на ваш файл:

Важно:

names (имена классов) берутся из модели, поэтому ваша бизнес-логика должна опираться либо на class_id, либо на class_name, но согласованно

если вы меняли список классов в датасете, убедитесь, что вы не используете старые названия из COCO (они были у yolov8n.pt)

Шаг 3: быстрый sanity-check на Raspberry Pi

Проверка “модель вообще видит нужный класс”:

Если детекций нет или они странные, чаще всего причины такие:

другой imgsz на инференсе, чем ожидалось (попробуйте imgsz=640 как в обучении)

слишком высокий порог conf (попробуйте 0.15–0.25)

датасет не отражал реальную сцену Raspberry Pi (свет, фон, расстояние)

Экспорт модели: когда pt достаточно, а когда нужен другой формат

Форматы и практический смысл

| Формат | Что это | Плюсы на Raspberry Pi | Минусы и ограничения | |---|---|---|---| | *.pt | PyTorch-веса | проще всего подключить через Ultralytics | может быть медленнее и тяжелее по зависимостям | | *.onnx | универсальный граф модели | часто удобен для оптимизации и альтернативных рантаймов | зависит от поддержки операторов и окружения | | *.tflite | TensorFlow Lite | иногда выгодно для CPU и встраиваемых сценариев | конвертация может быть капризной, не всегда быстрее |

Практическое правило:

начинайте с best.pt, добейтесь корректной логики и качества

затем ускоряйтесь через параметры runtime (разрешение, пропуск кадров)

только потом пробуйте экспорт, если упёрлись в производительность

Экспорт через Ultralytics на ПК

Экспорт лучше делать на вашей “зоне обучения” (ПК/сервер), затем переносить результат.

Пример экспортов:

Параметр imgsz важен, потому что некоторые форматы экспорта чувствительны к входному размеру.

Инференс экспортированной модели тем же API

Ultralytics умеет работать не только с *.pt. Во многих случаях достаточно заменить путь к файлу модели:

Дальше model.predict(...) остаётся тем же.

Ускорение на Raspberry Pi: рычаги, которые реально работают

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

Рычаг 1: уменьшить вход модели (imgsz)

imgsz в predict определяет, в каком размере модель обрабатывает кадр.

Практика для Raspberry Pi 4:

640 даёт лучше качество, но меньше FPS

416 часто хороший компромисс

320 обычно заметно быстрее, но хуже по мелким объектам

Пример:

Рычаг 2: уменьшить разрешение кадра с камеры

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

Пример настройки камеры:

Если пробуете ускорять:

попробуйте size=(640, 480) вместо 1280, 720

если объект крупный, иногда достаточно size=(512, 384)

Рычаг 3: делать инференс не на каждом кадре

Если камера даёт 30 FPS, это не значит, что вы обязаны 30 раз в секунду запускать YOLO.

Сценарий “детектируем 10 раз в секунду, а кадры показываем/сохраняем чаще” часто полностью достаточен.

Пример простого пропуска кадров:

Рычаг 4: сузить область интереса (ROI)

ROI (region of interest) это прямоугольник кадра, в котором вам реально нужен поиск.

Пример (используя crop_roi из прошлой статьи):

Важно:

ROI ускоряет инференс, потому что вы уменьшаете “лишние пиксели”

ROI может снизить качество, если объект появляется за пределами области

Рычаг 5: поднять порог conf, если ложных срабатываний слишком много

Порог conf отсеивает неуверенные детекции.

выше conf означает меньше детекций и меньше ложных срабатываний

но можно потерять слабые (дальние/тёмные) объекты

Бизнес-логика поверх детекций: делаем реакцию устойчивой

Сырые детекции “из коробки” редко подходят для управления устройством. Нужны правила.

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

Шаг 1: фильтрация по классу и уверенности

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

Шаг 2: зона интереса на кадре

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

Определим зону как прямоугольник в пикселях: (x1, y1, x2, y2).

Такой подход понятен и устойчив: вы реагируете на центр объекта.

Шаг 3: антидребезг (debounce) по времени или по кадрам

Антидребезг это правило, которое предотвращает “дёрганье” решения, когда модель то видит объект, то нет.

Пример логики: считать событие “объект присутствует”, только если он найден раз за последние кадров.

Пояснения:

window это длина окна истории (в кадрах)

min_hits это сколько “попаданий” нужно в этом окне

Шаг 4: действия: снимок, лог, GPIO, HTTP

На этом этапе детекции превращаются в прикладное поведение.

Типовые действия:

сохранить кадр при событии

отправить запрос на сервер (webhook)

включить светодиод/реле через GPIO

Пример “сохраняем снимок, когда объект стабильно присутствует”:

cooldown_sec нужен, чтобы не сохранять десятки файлов подряд.

Сборка в единый runtime: пример “обнаружил в зоне → подтверждение → действие”

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

Этот пример важен тем, что отделяет этапы:

детекции от модели

фильтрацию и геометрию (зона)

устойчивость решения (антидребезг)

действие (снимок) с защитой от спама (cooldown)

Как проверять ускорение корректно

Чтобы не “оптимизировать вслепую”, фиксируйте измерения.

Минимально полезный подход:

Выберите один сценарий сцены (одинаковый свет и объект).

Замерьте FPS при imgsz=640.

Поменяйте только один параметр (например, imgsz=416).

Сравните и решите, стоит ли компромисс качества.

Если вы одновременно меняете imgsz, разрешение камеры и частоту инференса, вы не понимаете, что именно дало эффект.

Частые проблемы при деплое и быстрые решения

| Симптом | Вероятная причина | Что сделать | |---|---|---| | На Raspberry Pi модель “не видит” класс, хотя на ПК всё ок | другая сцена, другой свет, другой масштаб | добавьте данные именно с Raspberry Pi AI Camera, снизьте conf, проверьте imgsz | | Много ложных срабатываний | мало негативных примеров, слишком низкий conf | добавьте негативные сцены, поднимите conf, используйте зону | | Событие “дёргается” | модель нестабильна на границе уверенности | добавьте антидребезг и cooldown | | FPS слишком низкий | тяжёлая модель или большой imgsz | уменьшите imgsz, делайте инференс реже, используйте ROI, попробуйте yolov8n |

Итог

К этому моменту у вас есть полный цикл от обученной модели до работающего приложения:

перенос best.pt на Raspberry Pi и подключение в пайплайн

понимание, когда нужен экспорт (onnx, tflite) и как его сделать

практические рычаги ускорения на Raspberry Pi 4

шаблон устойчивой бизнес-логики: фильтры → зона → антидребезг → действие

Дальше (в расширении проекта) обычно делают два шага:

визуализацию (отрисовка рамок и зон на кадре, локальный стрим)

интеграцию с внешним миром (GPIO, MQTT, HTTP, база событий)