Akceleracja GPU za pomocą LiteRT

Procesory graficzne (GPU) są powszechnie używane do przyspieszania uczenia głębokiego ze względu na ich ogromną przepustowość równoległą w porównaniu z procesorami CPU. LiteRT upraszcza proces korzystania z akceleracji GPU, umożliwiając użytkownikom określenie akceleracji sprzętowej jako parametru podczas tworzenia skompilowanego modelu (CompiledModel).

Dzięki akceleracji GPU w LiteRT możesz tworzyć bufory wejściowe i wyjściowe przyjazne dla GPU, osiągać zerowe kopiowanie danych w pamięci GPU i wykonywać zadania asynchronicznie, aby zmaksymalizować równoległość.

Rozpocznij

• W przypadku klasycznych modeli ML zapoznaj się z tymi aplikacjami demonstracyjnymi:

  • Aplikacja do segmentacji obrazów w Kotlinie: wnioskowanie na CPU/GPU/NPU.
  • Aplikacja C++ do segmentacji obrazu: wnioskowanie na CPU/GPU/NPU z wykonywaniem asynchronicznym.

• W przypadku modeli generatywnej AI zapoznaj się z tymi demonstracjami i tym przewodnikiem:

  • EmbeddingGemma semantic similarity C++ App: wnioskowanie na CPU, GPU i NPU.
  • Przewodnik po uruchamianiu LLM za pomocą LiteRT-LM.

Dodawanie zależności GPU

Aby dodać zależność GPU do aplikacji napisanej w Kotlinie lub C++, wykonaj te czynności.

Kotlin

W przypadku użytkowników języka Kotlin akcelerator GPU jest wbudowany i nie wymaga dodatkowych czynności poza tymi opisanymi w przewodniku Pierwsze kroki.

C++

W przypadku użytkowników C++ musisz skompilować zależności aplikacji z akceleracją GPU LiteRT. cc_binary reguła, która pakuje podstawową logikę aplikacji (np. main.cc) wymaga tych komponentów środowiska wykonawczego:

• Biblioteka współdzielona LiteRT C API: atrybut data musi zawierać bibliotekę współdzieloną LiteRT C API (//litert/c:litert_runtime_c_api_shared_lib) i komponenty specyficzne dla procesora graficznego (litert_gpu_accelerator_prebuilts).
• Zależności atrybutów: atrybut deps zwykle zawiera zależności GLESgles_deps(), a atrybut linkopts zwykle zawieragles_linkopts(). Oba te interfejsy są bardzo istotne w przypadku akceleracji za pomocą procesora graficznego, ponieważ LiteRT często używa OpenGLES na Androidzie.
• Pliki modelu i inne komponenty: uwzględnione za pomocą atrybutu data.

Oto przykład reguły 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
)

Ta konfiguracja umożliwia skompilowanemu plikowi binarnemu dynamiczne wczytywanie i używanie procesora graficznego do przyspieszonego wnioskowania w uczeniu maszynowym.

Gotowe akceleratory GPU

Nowy akcelerator GPU LiteRT nie jest jeszcze dostępny na licencji open source. Ale gotowe zestawy są dostępne. W przypadku użytkowników języka Kotlin pakiet Maven LiteRT zawiera już akceleratory GPU. Użytkownicy pakietu SDK C++ muszą pobrać go osobno, korzystając z tego.

W Bazelu możesz użyć tej reguły, aby dodać zależność do elementu docelowego. cpp load("//litert/build_common:special_rule.bzl", "litert_gpu_accelerator_prebuilts")

Korzystanie z GPU w interfejsie API CompiledModel

Aby zacząć korzystać z akceleratora GPU, podczas tworzenia skompilowanego modelu (CompiledModel) przekaż parametr GPU. Ten fragment kodu pokazuje podstawową implementację całego procesu:

// 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()

Więcej informacji znajdziesz w przewodnikach Pierwsze kroki z C++ i Pierwsze kroki z Kotlinem.

Kopiowanie zerowe z akceleracją GPU

Używanie zerowego kopiowania umożliwia procesorowi graficznemu bezpośredni dostęp do danych w jego własnej pamięci bez konieczności jawnego kopiowania tych danych przez procesor. Dzięki temu, że nie trzeba kopiować danych do pamięci procesora ani z niej, zero-copy może znacznie skrócić opóźnienie od początku do końca.

Poniższy kod to przykładowa implementacja Zero-Copy GPU z OpenGL, interfejsem API do renderowania grafiki wektorowej. Kod przekazuje obrazy w formacie bufora OpenGL bezpośrednio do 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());

Asynchroniczne wykonywanie

Asynchroniczne metody LiteRT, takie jak RunAsync(), umożliwiają planowanie wnioskowania na GPU podczas wykonywania innych zadań na CPU lub NPU. W złożonych potokach procesor graficzny jest często używany asynchronicznie wraz z procesorem lub jednostkami NPU.

Ten fragment kodu jest oparty na kodzie podanym w przykładzie Akceleracja GPU bez kopiowania. Kod używa procesora i procesora graficznego asynchronicznie i dołącza do bufora wejściowego LiteRT Event. LiteRT Event odpowiada za zarządzanie różnymi typami elementów synchronizacji, a poniższy kod tworzy zarządzany obiekt zdarzenia LiteRT typu LiteRtEventTypeEglSyncFence. Ten obiekt Event zapewnia, że nie będziemy odczytywać danych z bufora wejściowego, dopóki GPU nie zakończy pracy. Wszystko to odbywa się bez udziału procesora.

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));

Obsługiwany backend

LiteRT obsługuje te back-endy GPU na poszczególnych platformach:

Obsługiwane modele

LiteRT obsługuje akcelerację GPU w przypadku tych modeli: Wyniki testów porównawczych są oparte na testach przeprowadzonych na urządzeniu Samsung Galaxy S24.