Как мы в Ultralytics ускоряем модели YOLO на твоем любимом чипе

В Ultralytics мы создаем модели компьютерного зрения; по сути, мы учим компьютеры видеть! Представь эти модели как гигантские математические рецепты. Они состоят из операций (мы называем их слоями) и огромного набора чисел, которые мы называем весами.

Наши модели Ultralytics YOLO обрабатывают изображения такими, какими они являются на самом деле: массивами чисел! Каждый пиксель — это просто значения цвета, количество красного, зеленого и синего (RGB) для каждой точки, составляющей изображение. Мы называем эти массивы чисел «тензорами», потому что это звучит гораздо круче, чем «многомерные матрицы», что само по себе звучит круче, чем «числа, сложенные в числа, сложенные в числа».

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

Что получается на выходе? Еще больше чисел! Осмысленных чисел. В задачах обнаружения они говорят тебе, где именно находятся объекты на изображении и чем они, скорее всего, являются. «Эй, с вероятностью 95% это собака по координатам (x, y)!» Мы называем этот магический процесс инференсом.

Теперь, прежде чем наши модели смогут творить свою магию, им нужно пойти в школу; их нужно обучить. Часть с обучением — это когда всё становится по-настоящему серьезно.

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

Мы по сути обучаем сеть через исправление: каждая ошибка учит ее тому, чего НЕ СЛЕДУЕТ делать, и мы подправляем все эти веса так, чтобы при следующем просмотре похожего изображения она была ближе к верному ответу. По сути, сеть учится, получая подсказки в правильном направлении, ошибка за ошибкой, пока не начнет точно предсказывать.

О каком количестве чисел идет речь? Ну, наша милая маленькая YOLO11n имеет несколько миллионов параметров. А YOLO11x? Этот мощный зверь содержит более 50 миллионов параметров! Больше параметров — больше деталей, которые ты можешь закодировать, примерно как разница между рисованием мелками и наличием полной палитры художника.

Во время инференса этот параметр количества становится критически важным. Запуск сети с 3 миллионами параметров — это как пробежка вокруг квартала. Запуск сети с 50 миллионами параметров? Это скорее похоже на марафон с жонглированием горящими факелами.

Так что же такое вычисления на самом деле? Как происходит вся эта обработка чисел? Как мы делаем её быстрее? И что вообще значит «оптимизация вычислений»?

Link to this sectionКак чипы на самом деле выполняют вычисления#

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

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

Давай уберем эти слои. Возьмем этот простейший код на Python:

x = 1
if x == 1:
    y = x + 1

Мы создаем переменную x, устанавливаем её в 1, и если x равно 1 (спойлер: да), мы создаем y со значением x плюс 1. Три строки. Легко.

Но вот где становится интересно. Между этими тремя невинными строками и реальными электронами, движущимися по кремнию, происходит КАК МИНИМУМ четыре огромных уровня перевода (на самом деле их больше, но наш менеджер по цифровому контенту говорит, что мой объем текста уже вызывает у нее тревогу). Позволь мне провести тебя через это умопомрачительное путешествие:

Слой 1: Python → Байт-код Сначала Python считывает твой код и компилирует его в нечто, называемое байт-кодом, промежуточный язык, который легче переварить компьютерам, но от которого у тебя потекли бы глаза, если бы ты попытался его прочитать.

Слой 2: Байт-код → Машинный код Интерпретатор Python (например, CPython) берет этот байт-код и переводит его в машинный код, реальные инструкции, которые понимает твой процессор. Это то место, где твое элегантное «if x == 1» становится чем-то вроде «LOAD register, COMPARE register, JUMP if zero flag set».

Слой 3: Машинный код → Микрокод Неожиданный поворот! Современные процессоры даже не исполняют машинный код напрямую. Они разбивают его дальше на микрокод, еще более крошечные операции, с которыми могут справиться внутренние компоненты чипа. Твоя единственная инструкция «ADD» может превратиться в несколько микроопераций.

Слой 4: Микрокод → Физическая электроника Наконец, мы достигаем кремния. Эти микрооперации запускают реальные электрические сигналы, которые текут через транзисторы. Миллиарды крошечных переключателей включаются и выключаются, электроны танцуют по тщательно спроектированным путям, и каким-то магическим образом 1 + 1 становится 2.

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

Ирония? Те три строки Python, вероятно, запускают МИЛЛИОНЫ переключений транзисторов. Но благодаря этим абстракциям тебе не нужно думать ни о чем из этого. Ты просто пишешь «y = x + 1» и доверяешь тому, что где-то глубоко в кремнии происходит магия.

Link to this sectionАрхитектура#

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

У нас есть сотни разных чипов на рынке, каждый из которых предназначен для разных целей. Что меняется между ними? Топология, то, как операции расположены и реализованы в физической области. Это то, что мы называем архитектурой, и, поверь, у нас их много:

• x86 (Intel и AMD) — дедушка настольных вычислений, сложный, но мощный
• ARM — питает твой телефон и всё чаще твой ноутбук, разработан для эффективности
• RISC-V — повстанец с открытым исходным кодом, набирающий обороты везде
• PowerPC — зверь от IBM, до сих пор работающий в игровых консолях и серверах
• MIPS — любимец академиков, простой и элегантный
• SPARC — вклад Sun Microsystems (сейчас Oracle) в высокопроизводительные вычисления
• Архитектуры GPU (ядра NVIDIA CUDA, AMD RDNA) — монстры параллельной обработки

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

Link to this sectionСердцебиение кремния#

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

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

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

НИЧЕГО не происходит между тактовыми циклами. Весь компьютер замирает, ожидая следующего удара. Это как самая экстремальная игра в «красный свет, зеленый свет» во вселенной. На каждый «зеленый свет» (тактовый импульс):

• Данные перемещаются между компонентами
• Выполняются вычисления
• Принимаются логические решения
• Память считывается или записывается

Некоторые операции занимают один цикл (простое сложение), в то время как другие занимают много циклов (деление или получение данных из RAM). Всё точно хореографировано, миллиарды компонентов выполняют свои специфические операции, все синхронизированы с этим неумолимым ритмом.

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

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

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

Эта простота означает, что если у тебя есть переключатели, любые переключатели, ты можешь построить компьютер. Люди строили рабочие компьютеры из водопроводных труб и клапанов, домино, кубиков LEGO, шариков и даже с помощью редстоуна в Minecraft.

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

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

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

Link to this sectionЗаставляем нейронные сети делать ВРУУУУУМ#

Ладно, у нас есть эти чипы с миллиардами переключателей, танцующими под ритм кристалла, и мы хотим запускать на них нейронные сети с миллионами параметров. Должно быть легко, верно? Просто брось числа в чип и пусть он жжет!

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

Link to this sectionНесоответствие архитектуры#

Большинство чипов были разработаны для запуска Microsoft Word, а не нейронных сетей. Твой CPU был создан с мыслью, что он проведет жизнь, выполняя if-выражения, циклы и иногда рассчитывая твои налоги (единственное вычисление, которое даже суперкомпьютеры находят эмоционально истощающим). Он оптимизирован для последовательных операций: сделай это, затем то, затем другое.

Но нейронные сети совершенно другие. Они хотят делать ВСЁ ОДНОВРЕМЕННО. Во время обучения ты обновляешь миллионы весов на основе того, насколько неверными были твои предсказания. Во время инференса (фактического использования обученной модели) ты проталкиваешь данные через миллионы вычислений одновременно. Представь, что тебе нужно умножить миллион чисел на другой миллион чисел. Твой CPU, благослови его сердце, хочет делать их по одному, как очень быстрый, но очень методичный бухгалтер.

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

Но даже GPU не идеальны для нейронных сетей. Вот почему компании сейчас строят специализированные AI-чипы (TPU, NPU и каждый другой акроним, заканчивающийся на PU). Эти чипы разработаны с нуля с одной задачей: заставить нейронные сети работать быстро. Они похожи на наем повара, который умеет готовить только одно блюдо, но делает это со сверхчеловеческой скоростью. В то время как твой CPU мучается с матричными операциями последовательно, а твой GPU справляется с ними довольно неплохо параллельно, эти специализированные чипы едят матрицы на завтрак, обед и ужин.

Link to this sectionСтена памяти (Или: Почему перемещать биты сложнее, чем считать)#

В современных вычислениях нейронных сетей мы тратим больше времени и энергии на ПЕРЕМЕЩЕНИЕ данных, чем на реальные ВЫЧИСЛЕНИЯ с ними.

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

Твой чип может умножить два числа за один такт (помнишь, это один из тех миллиардов ударов в секунду). Молниеносно! Но получить эти числа из памяти в чип? Это может занять СОТНИ циклов. Это как если бы твой математик мог решить задачу за одну секунду, но ему нужно пять минут, чтобы дойти до библиотеки и обратно.

Причина — расстояние (и пространство). Электричество движется быстро, но не бесконечно быстро. Чем дальше данные должны перемещаться на чипе, тем дольше это занимает. Дизайнеры компьютеров решили это, создав иерархию памяти, как если бы было несколько мест хранения на разных расстояниях:

• Регистры (встроены непосредственно в вычислительные блоки): Рабочий стол твоего математика. Мгновенный доступ! Но он крошечный, здесь можно держать только около 32 чисел. Это как иметь стикеры прямо перед собой.
• Кэш L1 (в микрометрах): Книжная полка в офисе. Требуется 3-4 цикла, чтобы что-то схватить. Здесь можно разместить несколько тысяч чисел.
• Кэш L2 (в миллиметрах): Картотечный шкаф в коридоре. Занимает 10-15 циклов и вмещает пару миллионов чисел.
• Кэш L3 (через весь чип): Кладовая внизу. Занимает 30-50 циклов, вмещая десятки миллионов чисел.
• RAM (на совершенно другом чипе): Склад через весь город. Занимает 100-300 циклов. Именно здесь живут твои миллиарды чисел.
• SSD/Жесткий диск (подключен кабелями): Совершенно другой город. Занимает миллионы циклов. Огромное хранилище, ледниковая скорость.

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

А вот где становится больно для нейронных сетей. Представь, что твоя модель Ultralytics YOLO имеет 50 миллионов параметров (кстати, у ChatGPT их миллиарды). Это 50 миллионов чисел, которые должны перемещаться из памяти в вычислительные блоки и обратно. Даже если каждое число — всего 4 байта, это 200 мегабайт данных, которые должны пройти через твою систему.

Чип может обрабатывать каждое число за один цикл, но если требуется 100 циклов, чтобы достать это число из RAM, ты тратишь 99% времени в ожидании доставки. Это как иметь гоночный болид Formula 1 в пробке. Вся эта вычислительная мощь просто сидит там, ожидая прихода данных.

Вот важнейшее понимание: это БУТЫЛОЧНОЕ ГОРЛЫШКО в современных вычислениях. Оно называется узким местом фон Неймана. Сделать чипы быстрее в математике относительно легко. Сделать память быстрее — это значит упереться в физические ограничения. Именно поэтому почти ВСЯ оптимизация производительности в AI происходит на уровне памяти. Когда инженеры ускоряют нейронные сети, они редко делают математику быстрее; они находят умные способы меньше перемещать данные, лучше кэшировать их или обращаться к ним умнее.

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

Каждый раз, когда ты перемещаешь бит данных, ты тратишь энергию. Не много, речь идет о пикоджоулях, но когда ты перемещаешь терабайты в секунду, это ОЧЕНЬ БЫСТРО суммируется. На самом деле, перемещение данных на 1 мм по чипу потребляет больше энергии, чем выполнение самих вычислений!

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

Современные ускорители AI — это, по сути, упражнения по термодинамике. Сколько вычислений мы можем упаковать, прежде чем чип расплавится? Как быстро мы можем отвести тепло? Это как разгон, но частота всегда на 11, и мы просто пытаемся не устроить пожар.

Link to this sectionРешение? Дизайн с учетом архитектуры#

Самые быстрые нейронные сети не обязательно самые умные, они те, что разработаны с мыслью о чипах. Они:

• Держат данные максимально локально
• Одержимо используют повторные вычисления
• Идеально подстраиваются под возможности оборудования
• Минимизируют перемещение памяти любой ценой

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

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

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

Link to this sectionКак мы делаем YOLO быстрее#

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

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

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

Link to this sectionСлияние операций: Делаем больше меньшими усилиями#

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

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

1. Вычислить свертку → Сохранить в память
2. Загрузить из памяти → Нормализовать → Сохранить в память
3. Загрузить из памяти → Применить активацию → Сохранить в память

Мы делаем:

1. Вычислить свертку + нормализацию + активацию → Сохранить в память

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

Link to this sectionИспользование меньших чисел: Магия квантования#

YOLO на самом деле не нужны сверхточные числа, чтобы точно обнаруживать объекты. Во время обучения мы используем 32 бита для представления каждого веса — это как использовать научный калькулятор для измерения ингредиентов для сэндвича. А для реального развертывания? 8 бит работают просто отлично работают отлично.

Это называется квантованием, и это один из наших самых мощных методов оптимизации. Использование меньших чисел позволяет:

• Уменьшить размер модели на 75% (с 200 МБ до 50 МБ для Ultralytics YOLO11x)
• Ускорить работу в 2-4 раза на большинстве устройств
• Значительно снизить энергопотребление (аккумулятор твоего телефона скажет тебе спасибо)

Далеко не все слои в YOLO одинаково чувствительны к такому сжатию. Первые слои, которые обнаруживают базовые контуры и формы? Они устойчивы — мы можем использовать 8-битные числа без каких-либо проблем. Последние слои детекции, которые определяют «это кошка или собака?», требуют немного больше точности. Поэтому мы настраиваем точность слой за слоем, используя ровно столько бит, сколько нужно для сохранения точности при максимальном ускорении.

Мы обнаружили, что при тщательном квантовании Ultralytics YOLO сохраняет 99,5% своей исходной точности, работая в 3 раза быстрее на телефонах. В этом и заключается разница между исследовательской моделью и тем, что ты действительно можешь использовать в реальном мире.

Link to this sectionВыбор лучшего алгоритма#

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

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

Link to this sectionПамять: скрытое «бутылочное горлышко»#

Помнишь, мы говорили о том, что память является реальным «бутылочным горлышком» в современных вычислениях? Это особенно верно для YOLO. У модели может быть 50 миллионов параметров, и во время инференса она создает гигабайты промежуточных результатов. Перемещение всех этих данных часто занимает больше времени, чем сами вычисления.

Мы используем несколько приемов для минимизации перемещения данных в памяти:

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

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

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

Link to this sectionПрунинг (прореживание): Меньше значит больше#

Вот удивительный факт: модели YOLO часто переусложнены. Мы можем удалить 30% каналов во многих слоях практически без влияния на точность. Это не просто делает модель меньше — она становится быстрее, потому что вычислений буквально становится меньше.

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

Link to this sectionАппаратное ускорение: использование сильных сторон каждого чипа#

Разные процессоры хороши в разных задачах, и разница в производительности поразительна. Одна и та же модель YOLO11n требует:

• 45 миллисекунд на кадр на современном процессоре Intel
• 4 миллисекунды на графическом процессоре NVIDIA RTX
• 22 миллисекунды на мощном телефонном процессоре
• 15 миллисекунд на Google Coral edge TPU

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

Ключ к оптимизации — сопоставление операций YOLO с тем, что каждый чип делает лучше всего. GPU любит выполнять одну и ту же операцию над множеством данных одновременно. Мобильный NPU может поддерживать только определенные операции, но выполняет их невероятно эффективно. Edge TPU работает только с 8-битными целыми числами, но достигает невероятной скорости в рамках этого ограничения.

Link to this sectionМагия компиляции#

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

1. Анализирует твою модель, чтобы понять ее структуру и требования
2. Учитывает возможности твоего оборудования — в чем оно хорошо, а с чем справляется с трудом
3. Генерирует оптимизированный код, который «говорит» на родном языке твоего оборудования

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

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

Link to this sectionРеальное развертывание на edge-устройствах#

Давай поговорим о том, что происходит, когда YOLO сталкивается с реальным миром — в частности, со сложным миром edge-устройств. Представь камеру наблюдения, которой нужно запускать YOLO 24/7 для обнаружения объектов. Она сталкивается с жесткими ограничениями:

• Память: Возможно, всего 512 МБ – 2 ГБ оперативной памяти в сумме
• Питание: Часто всего 2–5 Вт (меньше, чем зарядное устройство для телефона)
• Охлаждение: Без вентиляторов, только пассивный отвод тепла
• Надежность: Должна работать непрерывно без сбоев

Вот чего достигает оптимизация на практике. Камера наблюдения, запускающая YOLO11s:

• Оригинальная модель: 15 Вт, нагревается до 85°C, достигает 20 FPS
• Оптимизирована с помощью квантования и прунинга: 3 Вт, комфортные 45°C, достигает 25 FPS

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

Ключ к успеху — выбор правильных компромиссов. На edge-устройствах мы часто:

• Используем INT8-квантование (меньше точности, намного меньше энергопотребления)
• Обрабатываем меньше кадров при низкой активности
• Распределяем работу между разными процессорами для управления нагревом
• Сохраняем модели достаточно компактными, чтобы они целиком помещались в быструю память

Link to this sectionПроцесс оптимизации#

В Ultralytics мы следуем систематическому подходу к оптимизации. Сначала мы профилируем модель, чтобы понять, на что на самом деле тратится время. Часто «бутылочные горлышки» находятся не там, где ты ожидаешь. Возможно, 80% времени тратится всего на несколько слоев, или передача данных в памяти доминирует над временем вычислений.

Затем мы применяем оптимизации итеративно:

1. Начни с самых больших «бутылочных горлышек»
2. Применяй по одной оптимизации за раз
3. Измеряй как прирост скорости, так и влияние на точность
4. Сохраняй те оптимизации, которые обеспечивают хорошие компромиссы
5. Повторяй, пока не достигнешь целей

Например, при развертывании YOLO11m на телефоне:

• Базовая линия: 200 мс на кадр, модель 200 МБ
• После квантования: 80 мс на кадр, модель 50 МБ
• После прунинга: 60 мс на кадр, модель 35 МБ
• После объединения операций (operation fusion): 45 мс на кадр, модель 35 МБ

Каждый шаг повышает производительность при сохранении более 99% исходной точности. Результат? Детекция объектов в реальном времени на устройстве, которое помещается у тебя в кармане.

Link to this sectionБудущее: Гетерогенные вычисления#

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

• Камерный сенсор имеет ISP (Image Signal Processor) для предобработки
• NPU (Neural Processing Unit) выполняет инференс YOLO
• CPU обрабатывает сложную логику и координацию
• GPU отрисовывает результаты на экране

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

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

Link to this sectionИтог#

Оптимизация моделей YOLO — это не просто конвертация форматов файлов; это превращение передового ИИ в нечто, что действительно работает в реальном мире. Благодаря таким методам, как квантование (использование меньших чисел), прунинг (удаление лишних частей), объединение операций и умное управление памятью, мы добиваемся 10–100-кратного повышения производительности при сохранении точности.

Что самое замечательное? Не существует универсальной «лучшей» оптимизации. Облачному серверу с неограниченной мощностью нужны другие оптимизации, чем дрону на батарейках. Телефону со специализированным ИИ-чипом нужно другое отношение, чем Raspberry Pi. Вот почему Ultralytics предоставляет так много вариантов экспорта — каждый из них оптимизирован для разных сценариев.

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

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

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