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

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

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

Примеры реализации LiteRT GPU можно найти в следующих демонстрационных приложениях:

• Сегментация изображений с помощью Kotlin
• Асинхронная сегментация с использованием C++

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

Выполните следующие шаги, чтобы добавить зависимость от графического процессора в ваше приложение на 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//:jni/arm64-v8a/libLiteRtGpuAccelerator.so ).
• Атрибут dependencies : Атрибут deps обычно включает зависимости GLES gles_deps() , а linkopts обычно включает gles_linkopts() . Оба атрибута очень важны для ускорения работы GPU, поскольку LiteRT часто использует OpenGLES на Android.
• Файлы моделей и другие ресурсы : включаются посредством атрибута data .

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

cc_binary(
    name = "your_application",
    srcs = [
        "main.cc",
    ],
    data = [
        ...
        # litert c api shared library
        "//litert/c:litert_runtime_c_api_shared_lib",
        # GPU accelerator shared library
        "@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so",
    ],
    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
)

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

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

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

// 1. Load model
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));

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

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

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

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

// 6. 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 model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, 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, model, 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 поддерживает ускорение графического процессора на следующих моделях. Результаты бенчмарков основаны на тестах, проведенных на устройстве Samsung Galaxy S24.