Ускорение графического процессора с помощью LiteRT

Графические процессоры (GPU) широко используются для ускорения глубокого обучения благодаря их огромной параллельной пропускной способности по сравнению с центральными процессорами (CPU). LiteRT упрощает процесс использования аппаратного ускорения GPU, позволяя пользователям указывать аппаратное ускорение в качестве параметра при создании скомпилированной модели ( CompiledModel ).

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

Начать

• Для ознакомления с классическими моделями машинного обучения см. следующие демонстрационные приложения.

  • Приложение Kotlin для сегментации изображений : вывод данных на CPU/GPU/NPU.
  • Приложение для сегментации изображений на C++ : вывод данных с использованием CPU/GPU/NPU с асинхронным выполнением.

• Для ознакомления с моделями GenAI см. следующие демонстрации и руководство:

  • Приложение EmbeddingGemma для определения семантического сходства на C++ : вывод данных с использованием CPU/GPU/NPU.
  • Руководство по запуску LLM-моделей с использованием LiteRT-LM .

Добавить зависимость от графического процессора.

Выполните следующие шаги, чтобы добавить зависимость от графического процессора в ваше приложение на Kotlin или C++.

Котлин

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

C++

Для пользователей C++ необходимо скомпилировать зависимости приложения с использованием ускорения LiteRT GPU. Правило cc_binary , которое упаковывает основную логику приложения (например, main.cc ), требует наличия следующих компонентов среды выполнения:

• Библиотека LiteRT C API : атрибут data должен включать библиотеку LiteRT C API ( //litert/c:litert_runtime_c_api_shared_lib ) и компоненты, специфичные для графического процессора ( litert_gpu_accelerator_prebuilts ).
• Атрибут dependencies : Атрибут deps обычно включает зависимости GLES gles_deps() , а linkopts обычно включает gles_linkopts() . Оба атрибута очень важны для ускорения работы GPU, поскольку LiteRT часто использует OpenGLES на Android.
• Файлы моделей и другие ресурсы : включаются посредством атрибута data .

Ниже приведён пример правила cc_binary :

load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

cc_binary(
    name = "your_application",
    srcs = [
        "main.cc",
    ],
    data = [
        ...
        # litert c api shared library
        "//litert/c:litert_runtime_c_api_shared_lib",
    ] + litert_gpu_accelerator_prebuilts(),
    linkopts = select({
        "@org_tensorflow//tensorflow:android": ["-landroid"],
        "//conditions:default": [],
    }) + gles_linkopts(), # gles link options
    deps = [
        ...
        "//litert/cc:litert_tensor_buffer", # litert cc library
        ...
    ] + gles_deps(), # gles dependencies
)

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

Предварительно собранные графические ускорители

Новый ускоритель LiteRT для графических процессоров пока не является открытым исходным кодом. Но доступны предварительно собранные версии. Для пользователей Kotlin пакет LiteRT Maven уже содержит ускорители для графических процессоров. Пользователям SDK для C++ необходимо загрузить его отдельно, используя эту ссылку .

В Bazel для добавления зависимости к вашей цели можно использовать следующее правило: ` cpp load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

Использование графического процессора с API CompiledModel

Для начала использования графического ускорителя передайте параметр GPU при создании скомпилированной модели ( CompiledModel ). Следующий фрагмент кода демонстрирует базовую реализацию всего процесса:

// 1. Create a compiled model targeting GPU
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model, CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// 2. Prepare input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// 3. Fill input data (if you have CPU-based data)
input_buffers[0].Write<float>(absl::MakeConstSpan(cpu_data, data_size));

// 4. Execute
compiled_model.Run(input_buffers, output_buffers);

// 5. Access model output
std::vector<float> data(output_data_size);
output_buffers.Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.GPU),
        env,
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Для получения более подробной информации см. руководства « Начало работы с C++» или «Начало работы с Kotlin» .

Копирование без копирования с ускорением на графическом процессоре

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

Приведённый ниже код представляет собой пример реализации технологии Zero-Copy GPU с использованием OpenGL , API для рендеринга векторной графики. Код передаёт изображения в формате буфера OpenGL непосредственно в LiteRT:

// Suppose you have an OpenGL buffer consisting of:
// target (GLenum), id (GLuint), size_bytes (size_t), and offset (size_t)
// Load model and compile for GPU
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// Create a TensorBuffer that wraps the OpenGL buffer.
LITERT_ASSIGN_OR_RETURN(auto tensor_type, model.GetInputTensorType("input_tensor_name"));
LITERT_ASSIGN_OR_RETURN(auto gl_input_buffer, TensorBuffer::CreateFromGlBuffer(env,
    tensor_type, opengl_buffer.target, opengl_buffer.id, opengl_buffer.size_bytes, opengl_buffer.offset));
std::vector<TensorBuffer> input_buffers{gl_input_buffer};
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Execute
compiled_model.Run(input_buffers, output_buffers);

// If your output is also GPU-backed, you can fetch an OpenCL buffer or re-wrap it as an OpenGL buffer:
LITERT_ASSIGN_OR_RETURN(auto out_cl_buffer, output_buffers[0].GetOpenClBuffer());

Асинхронное выполнение

Асинхронные методы LiteRT, такие как RunAsync() , позволяют планировать выполнение задач на графическом процессоре, продолжая при этом другие задачи на центральном процессоре или нейронном процессоре. В сложных конвейерах графический процессор часто используется асинхронно наряду с центральным процессором или нейронным процессором.

Приведенный ниже фрагмент кода основан на коде, представленном в примере ускорения GPU без копирования . Код использует как CPU, так и GPU асинхронно и прикрепляет Event LiteRT к входному буферу. Event LiteRT отвечает за управление различными типами примитивов синхронизации, и следующий код создает управляемый объект события LiteRT типа LiteRtEventTypeEglSyncFence . Этот объект Event гарантирует, что чтение из входного буфера не будет производиться до завершения работы GPU. Все это выполняется без участия CPU.

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, "mymodel.tflite", kLiteRtHwAcceleratorGpu));

// 1. Prepare input buffer (OpenGL buffer)
LITERT_ASSIGN_OR_RETURN(auto gl_input,
    TensorBuffer::CreateFromGlBuffer(env, tensor_type, opengl_tex));
std::vector<TensorBuffer> inputs{gl_input};
LITERT_ASSIGN_OR_RETURN(auto outputs, compiled_model.CreateOutputBuffers());

// 2. If the GL buffer is in use, create and set an event object to synchronize with the GPU.
LITERT_ASSIGN_OR_RETURN(auto input_event,
    Event::CreateManagedEvent(env, LiteRtEventTypeEglSyncFence));
inputs[0].SetEvent(std::move(input_event));

// 3. Kick off the GPU inference
compiled_model.RunAsync(inputs, outputs);

// 4. Meanwhile, do other CPU work...
// CPU Stays busy ..

// 5. Access model output
std::vector<float> data(output_data_size);
outputs[0].Read<float>(absl::MakeSpan(data));

Поддерживаемая серверная часть

LiteRT поддерживает следующие графические процессоры для каждой платформы.

Поддерживаемые модели

LiteRT поддерживает ускорение графического процессора на следующих моделях. Результаты бенчмарков основаны на тестах, проведенных на устройстве Samsung Galaxy S24.