Разработка приложений искусственного интеллекта на границе сети (edge AI) часто сталкивается с жесткими ограничениями по вычислительной мощности и энергопотреблению. На платформах NVIDIA Jetson, таких как AGX Orin, разработчикам необходимо эффективно распределять нагрузку между центральным процессором (CPU), графическим процессором (GPU) и специализированными ускорителями. Одной из ключевых технологий для оптимизации инференса нейронных сетей является Deep Learning Accelerator (DLA). DLA представляет собой выделенное аппаратное обеспечение, предназначенное для выполнения операций глубокого обучения с высокой энергоэффективностью, освобождая ресурсы GPU для других задач приложения.
Ранее интеграция DLA требовала написания сложного кода на C++ или использования высокоуровневых библиотек, которые могли скрывать детали управления памятью и потоками. Однако с появлением модуля cudla в рамках проекта CUDA Python, разработчики получили прямой доступ к API DLA из Python. Это открывает новые возможности для создания гибридных рабочих процессов, где предобработка данных выполняется на GPU, инференс — на DLA, а постобработка снова на GPU, все это координируется через единые CUDA-потоки. В этой статье мы подробно разберем, как настроить среду, скомпилировать модель и запустить полный цикл инференса на Jetson AGX Orin, используя современные инструменты NVIDIA.
01Архитектура cuDLA и место в стеке Python
Deep Learning Accelerator (DLA) — это акселератор с фиксированной функцией. Это означает, что он оптимизирован для эффективного выполнения определенного набора операций, таких как свертки (convolutions) и пулинг (pooling), которые являются строительными блоками современных архитектур нейронных сетей. Хотя DLA поддерживает не все слои, доступные на GPU, его покрытие достаточно широко для запуска множества популярных моделей. Главное преимущество DLA заключается в энергоэффективности: он выполняет инференс, не нагружая основной GPU, что критически важно для устройств с ограниченным питанием, таких как роботы или автономные дроны.
Модуль cudla (в составе пакета cuda-bindings) представляет собой тонкий слой обертки, сгенерированный с помощью Cython, над C++ API cuDLA. Он был представлен в версии 13.3.0 проекта CUDA Python. Этот модуль экспортирует 13 функций, 9 типов данных и 8 перечислений (enums), необходимых для работы в гибридном режиме. Гибридный режим — это ключевая концепция, позволяющая синхронизировать выполнение задач на DLA с работой GPU через CUDA-потоки.
На платформах NVIDIA JetPack библиотека libcudla.so поставляется в комплекте с системой, что упрощает установку. Вам не нужно устанавливать отдельный SDK для DLA. Python-биндинги позволяют управлять временем выполнения и оркестровкой инференса непосредственно из Python-кода, избегая необходимости писать и компилировать C++ код для управления ресурсами. Это делает процесс разработки более быстрым и гибким.

Расширение за пределы встроенных систем: NVIDIA RTX Spark
Хотя данная статья фокусируется на Jetson AGX Orin, важно отметить, что API cudla универсален. Он также применяется в NVIDIA RTX Spark, что позволяет запускать DLA-инференс на обычных Windows-ноутбуках для разработчиков ИИ. Это расширяет сферу применения DLA за пределы встроенных систем и робототехники, позволяя использовать специализированные ускорители даже на десктопных платформах. API остается идентичным, поэтому знания, полученные при работе с Jetson, можно легко перенести на другие платформы.
02Подготовка среды и установка зависимостей
Для начала работы вам потребуется устройство NVIDIA Jetson AGX Orin с установленной версией JetPack 7.2.2 или новее. В этой версии JetPack уже включена необходимая библиотека libcudla.so, которая автоматически обнаруживается биндингами. Таким образом, установка самого рантайма DLA не требует дополнительных действий.
Основной шаг — установка Python-пакета cuda-bindings. Рекомендуется использовать версию 13.3.0 или новее. Однако здесь есть важный нюанс: стандартная версия Python в JetPack может быть старше 3.10, тогда как минимальная требуемая версия для cuda-bindings — Python 3.10. На практике лучше использовать Python 3.12 для лучшей производительности и совместимости.
Ниже приведен полный скрипт для установки Python 3.12 из репозитория deadsnakes и создания виртуального окружения:
sudo apt update && sudo apt install -y software-properties-common
sudo add-apt-repository -y ppa:deadsnakes/ppa
sudo apt update && sudo apt install -y python3.12 python3.12-venv python3.12-dev
python3.12 -m venv ~/dla-env
source ~/dla-env/bin/activate
pip install "cuda-bindings>=13.3.0"Обратите внимание, что для запуска инференса вам не нужен TensorRT. TensorRT требуется только на этапе компиляции модели в формат DLA loadable. После того как у вас есть готовый файл модели (например, .bin или .nvdla), для выполнения инференса достаточно только libcudla.so и Python-биндингов. Это упрощает развертывание на целевом устройстве.

03Компиляция модели в DLA Loadable
DLA Loadable — это бинарный артефакт, созданный инструментом trtexec из TensorRT. Он кодирует обученную нейронную сеть в формате, который аппаратное обеспечение DLA может выполнять напрямую. Процесс компиляции выполняется один раз, а полученный файл затем используется для инференса.
Для компиляции модели в формат FP16 с фиксированными размерами входа, используйте следующую команду. Пример ориентирован на TensorRT 11.4.1 и CUDA 13.4 Update 1:
trtexec \
--onnx=your_model_fp16.onnx \
--useDLACore=0 \
--inputIOFormats=chw16 \
--outputIOFormats=chw16 \
--memPoolSize=dlaSRAM:1 \
--saveEngine=model.bin \
--buildDLAStandaloneРазберем ключевые флаги:
--useDLACore=0: указывает использовать первый DLA-движок на Orin. На AGX Orin доступно два DLA-ядра, поэтому можно использовать0или1.--buildDLAStandalone: генерирует «чистый» DLA loadable, который не требует наличия TensorRT во время выполнения инференса. Это критически важно для легковесного развертывания.--inputIOFormats=chw16: задает формат ввода CHW16 (Channels, Height, Width, с выравниванием каналов по 16). Этот формат оптимизирован для DLA.--memPoolSize=dlaSRAM:1: выделяет 1 МБ локальной SRAM памяти DLA для кэширования данных, что ускоряет доступ к весам модели.
Важное изменение в TensorRT 11: точность вывода теперь выводится из типов тензоров в самой модели ONNX. Флаги --fp16 и --int8 больше не поддерживаются в том же виде, что и раньше. Если ваша модель ONNX уже имеет типы данных FP16, TensorRT автоматически выберет этот формат. Также обратите внимание, что не все слои нейронной сети совместимы с DLA. Часто требуется предварительная обработка графа ONNX для удаления несовместимых слоев на входе и выходе модели.

04Рабочий процесс Python: 9 шагов к инференсу
Теперь перейдем к основной части — написанию Python-скрипта для выполнения инференса. Для работы нам понадобятся три импорта:
import numpy as np
from cuda.bindings import cudla
from cuda.bindings import driver, runtimeМодуль cudla отвечает за работу с DLA, а driver и runtime предоставляют доступ к стандартным API CUDA для управления потоками, памятью и передачей данных. Весь процесс можно разделить на 9 логических шагов.
Шаг 1: Инициализация CUDA и создание устройства DLA
Мы выбираем гибридный режим (CUDA_DLA), который позволяет отправлять задачи DLA через CUDA-поток. Это необходимо для координации с GPU-операциями.
driver.cuInit(0)
runtime.cudaSetDevice(0)
cudla_device = cudla.create_device(0, int(cudla.Mode.CUDA_DLA))Обратите внимание, что на данный момент standalone-режим (без использования CUDA-потоков) не поддерживается. Попытка создать устройство в другом режиме вызовет исключение CudlaError(ErrorUnsupportedOperation).
Шаг 2: Загрузка loadable
Загружаем скомпилированную модель из памяти. Нам не нужно передавать путь к файлу, достаточно передать байтовый объект. Это позволяет загружать модели из встроенных ресурсов, файлов с отображением в память или даже из сети.
with open("model.bin", "rb") as f:
loadable_data = f.read()
module_handle = cudla.module_load_from_memory(
cudla_device, loadable_data, len(loadable_data), 0
)Шаг 3: Интроспекция загруженного модуля
Перед выделением памяти необходимо узнать, какие тензоры ожидает модель. Мы запрашиваем количество входных и выходных тензоров, а также их дескрипторы. Это делает код универсальным: он будет работать с любой моделью, независимо от ее архитектуры.
num_inputs = cudla.module_get_attributes(
module_handle, int(cudla.ModuleAttributeType.NUM_INPUT_TENSORS)
)
num_outputs = cudla.module_get_attributes(
module_handle, int(cudla.ModuleAttributeType.NUM_OUTPUT_TENSORS)
)
input_descs = cudla.module_get_attributes(
module_handle, int(cudla.ModuleAttributeType.INPUT_TENSOR_DESCRIPTORS)
)
output_descs = cudla.module_get_attributes(
module_handle, int(cudla.ModuleAttributeType.OUTPUT_TENSOR_DESCRIPTORS)
)Каждый дескриптор содержит информацию о размере буфера (size_), форме тензора (n, c, h, w), имени, формате данных и шаге (stride). Использование этих значений вместо «зашитых» размеров делает код гибким.

Шаг 4: Выделение памяти GPU
Используя размеры из дескрипторов, выделяем память на GPU. Функции cudaMalloc возвращают кортеж, где первый элемент — код статуса, а второй — указатель на память. В продакшен-коде всегда проверяйте статусы.
input_gpu = runtime.cudaMalloc(input_descs[0].size_)[1]
output_gpu = runtime.cudaMalloc(output_descs[0].size_)[1]Шаг 5: Регистрация буферов GPU в cuDLA
Это уникальный шаг для cuDLA. Перед тем как DLA сможет использовать память GPU, буферы должны быть зарегистрированы. Регистрация возвращает дескриптор на стороне DLA, который аппаратное обеспечение использует для доступа к данным.
input_registered = cudla.mem_register(
cudla_device, int(input_gpu), input_descs[0].size_, 0
)
output_registered = cudla.mem_register(
cudla_device, int(output_gpu), output_descs[0].size_, 0
)Функция int() преобразует объект-указатель CUDA в целое число, которое требуется C-уровневым API. cudla.bindings возвращает непрозрачные объекты, и int() — это способ передать их как сырые указатели.
Шаг 6: Подготовка входных данных и копирование
Здесь выполняется предобработка данных. Вы должны подготовить массив NumPy (input_cpu), соответствующий формату, описанному в дескрипторе (stride, data_format, data_type). Затем асинхронно копируем данные на GPU.
stream = driver.cuStreamCreate(driver.CUstream_flags.CU_STREAM_NON_BLOCKING)[1]
# Предположим, input_cpu уже подготовлен
runtime.cudaMemcpyAsync(
input_gpu, input_cpu, input_descs[0].size_,
runtime.cudaMemcpyKind.cudaMemcpyHostToDevice, stream
)
# Инициализируем выходной буфер нулями
runtime.cudaMemsetAsync(output_gpu, 0, output_descs[0].size_, stream)Шаг 7: Создание задачи и отправка
Создаем объект задачи cudla.Task, назначаем ему модуль, входные и выходные тензоры (используя зарегистрированные дескрипторы) и отправляем задачу в поток.
task = cudla.Task()
task.module_handle = module_handle
task.input_tensor = [int(input_registered)]
task.output_tensor = [int(output_registered)]
task.wait_events = 0
task.signal_events = 0
cudla.submit_task(cudla_device, int(task), 1, int(stream), 0)Отправка задачи в поток означает, что она будет выполнена после всех предыдущих операций в этом потоке (например, после копирования данных) и перед последующими (например, после обработки результатов).
Шаг 8: Синхронизация и чтение результатов
После отправки задачи необходимо дождаться ее завершения. Сначала синхронизируем поток, чтобы убедиться, что DLA завершила вычисления. Затем копируем результат обратно на CPU.
runtime.cudaStreamSynchronize(stream)
output_cpu = np.empty(output_descs[0].size_, dtype=np.uint8)
runtime.cudaMemcpyAsync(
output_cpu, output_gpu, output_descs[0].size_,
runtime.cudaMemcpyKind.cudaMemcpyDeviceToHost, stream
)
runtime.cudaStreamSynchronize(stream)После второй синхронизации массив output_cpu содержит сырые данные инференса, готовые к постобработке.
Шаг 9: Очистка ресурсов
Важно корректно освободить все выделенные ресурсы. DLA-устройства и модули — это непрозрачные C-ресурсы, которые не освобождаются автоматически сборщиком мусора Python.
cudla.mem_unregister(cudla_device, input_registered)
cudla.mem_unregister(cudla_device, output_registered)
cudla.module_unload(module_handle, 0)
cudla.destroy_device(cudla_device)
runtime.cudaFree(input_gpu)
runtime.cudaFree(output_gpu)
driver.cuStreamDestroy(stream)05Обработка ошибок и управление исключениями
Одним из преимуществ Python-биндингов является нативная обработка ошибок. Все вызовы API cuDLA выбрасывают исключение cudla.CudlaError при возникновении ошибки, а не возвращают коды ошибок. Это позволяет использовать стандартные конструкции Python для обработки ошибок.
try:
device = cudla.create_device(0, int(cudla.Mode.CUDA_DLA))
except cudla.CudlaError as e:
print(e) # Вывод: "ErrorInvalidDevice (8)"Рекомендуется использовать конструкцию try/finally для гарантированной очистки ресурсов. Исключение содержит как числовой статус, так и его человеко-читаемое имя. Вы можете ветвить логику обработки, проверяя e.status против значений перечисления cudla.Status, чтобы различать ошибки параметров (ErrorInvalidParam) и аппаратные сбои (ErrorDlaErrEngineTimeout).
06Что это значит на практике
Использование cuDLA в Python открывает новые горизонты для разработчиков edge-AI. Во-первых, это значительно упрощает разработку. Вам не нужно писать сложные C++ обертки или использовать сложные фреймворки оркестровки. Весь цикл жизни инференса — от загрузки модели до получения результатов — управляется из Python.
Во-вторых, гибридный режим обеспечивает максимальную эффективность. Предобработка изображений (например, нормализация, изменение размера) может выполняться на GPU с использованием CUDA-ядер, затем данные передаются в DLA для инференса, а результаты снова обрабатываются на GPU. Все это происходит в рамках одного CUDA-потока, что минимизирует задержки и накладные расходы на синхронизацию.
В-третьих, универсальность дескрипторов тензоров делает код устойчивым к изменениям моделей. Если вы замените ResNet-50 на EfficientNet, ваш код инференса не потребует изменений, кроме, возможно, настройки предобработки данных. Дескрипторы автоматически предоставят нужные размеры и форматы.
Наконец, возможность запуска DLA-инференса на Windows-ноутбуках через RTX Spark позволяет разработчикам тестировать и отлаживать свои алгоритмы на привычных десктопных машинах, а затем переносить их на Jetson без изменений в коде. Это сокращает цикл разработки и упрощает переход от прототипа к продукту.
Для дальнейшего изучения рекомендуется ознакомиться с образцами Deep Learning Accelerator, которые содержат полный пример end-to-end инференса, включая скрипты подготовки и компиляции моделей. Также полезно изучить репозиторий NVIDIA/cuda-python для понимания общих принципов работы с CUDA Python и запуска модульных тестов.
Источник: NVIDIA Developer ↗
