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

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

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

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

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

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

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

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

О скольких числах идёт речь? Что ж, у нашей милой 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» превращается во что-то вроде «LOAD register, COMPARE register, JUMP if zero flag set».

Слой 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 GHz», GHz (гигагерц) — это тактовая частота: 3,5 миллиарда импульсов в секунду. Каждый импульс называется тактом, и это основная единица времени в вычислительной технике.

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

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

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

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

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

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

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

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

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

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

Заставляем нейросети РАБОТАТЬ НА ПОЛНУЮ#

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

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

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

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

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

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

Но даже GPU не идеально подходят для нейросетей. Поэтому компании создают специализированные микросхемы для ИИ (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 в пробку. Вся эта вычислительная мощность простаивает в ожидании данных.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Главное#

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

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

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

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

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