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

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

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

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

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

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

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

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

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

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

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

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

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

Это, вероятно, звучит странно, даже если ты компьютерный специалист. Дело в том, что последние 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» превращается во что-то вроде «ЗАГРУЗИТЬ регистр, СРАВНИТЬ регистр, ПЕРЕЙТИ, если установлен флаг нуля».

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

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

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

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

Архитектура#

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

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

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

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

Сердцебиение кремния#

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

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

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

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

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

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

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

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

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

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

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

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

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

Заставляем нейронные сети работать на полную#

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

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

Несоответствие архитектур#

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

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

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

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

Стена памяти (или почему перемещать биты сложнее, чем выполнять математику)#

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

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

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

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

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

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

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

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

Вот ключевая мысль: ЭТО узкое место современных вычислений. Оно называется узким местом фон Неймана. Ускорить математические операции в чипах относительно легко. А ускорение памяти упирается в физические ограничения. Поэтому почти ВСЯ оптимизация производительности в AI происходит на уровне памяти. Когда инженеры ускоряют нейронные сети, они редко делают математику быстрее; вместо этого они находят хитрые способы меньше перемещать данные, эффективнее кэшировать их или разумнее получать к ним доступ.

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

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

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

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

Решение? Проектирование с учётом архитектуры#

Самые быстрые нейронные сети не обязательно самые умные — это сети, спроектированные с учётом чипов. Они:

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

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

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

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

Как мы ускоряем YOLO#

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

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

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

Объединение операций: больше результата с меньшими затратами#

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

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

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

Мы выполняем:

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

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

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

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

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

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

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

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

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

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

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

Память: скрытое узкое место#

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

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

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

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

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

Прунинг: меньше — значит больше#

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

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

Аппаратное ускорение: используем сильные стороны каждого чипа#

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

• 45 миллисекунд на современном CPU Intel
• 4 миллисекунды на GPU NVIDIA RTX
• 22 миллисекунды на производительном процессоре телефона
• 15 миллисекунд на периферийном TPU Google Coral

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

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

Магия компиляции#

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

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

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

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

Развертывание на периферийных устройствах в реальном мире#

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

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

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

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

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

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

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

Процесс оптимизации#

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

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

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

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

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

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

Будущее: гетерогенные вычисления#

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

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

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

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

Итог#

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

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

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

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

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