GPU-Beschleunigung mit LiteRT

Graphics Processing Units (GPUs) werden aufgrund ihres massiven parallelen Durchsatzes im Vergleich zu CPUs häufig zur Beschleunigung von Deep Learning verwendet. LiteRT vereinfacht die Verwendung der GPU-Beschleunigung, da Nutzer die Hardwarebeschleunigung beim Erstellen eines kompilierten Modells (CompiledModel) als Parameter angeben können.

Mit der GPU-Beschleunigung von LiteRT können Sie GPU-freundliche Ein- und Ausgabepuffer erstellen, Zero-Copy mit Ihren Daten im GPU-Speicher erreichen und Aufgaben asynchron ausführen, um die Parallelität zu maximieren.

Beispielimplementierungen von LiteRT GPU finden Sie in den folgenden Demoanwendungen:

• Bildsegmentierung mit Kotlin
• Asynchrone Segmentierung mit C++

GPU-Abhängigkeit hinzufügen

Führen Sie die folgenden Schritte aus, um Ihrer Kotlin- oder C++-Anwendung eine GPU-Abhängigkeit hinzuzufügen.

Kotlin

Für Kotlin-Nutzer ist der GPU-Accelerator integriert und es sind keine zusätzlichen Schritte über die Kurzanleitung hinaus erforderlich.

C++

C++-Nutzer müssen die Abhängigkeiten der Anwendung mit LiteRT-GPU-Beschleunigung erstellen. Die cc_binary-Regel, die die Kernanwendungslogik verpackt (z.B. main.cc) sind die folgenden Laufzeitkomponenten erforderlich:

• Gemeinsame Bibliothek der LiteRT C API: Das Attribut data muss die gemeinsame Bibliothek der LiteRT C API (//litert/c:litert_runtime_c_api_shared_lib) und GPU-spezifische Komponenten (@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so) enthalten.
• Attributabhängigkeiten: Das Attribut deps enthält in der Regel GLES-Abhängigkeiten gles_deps() und linkopts enthält in der Regel gles_linkopts(). Beide sind für die GPU-Beschleunigung sehr wichtig, da LiteRT unter Android häufig OpenGLES verwendet.
• Modelldateien und andere Assets: Über das Attribut data eingebunden.

Das folgende Beispiel zeigt eine cc_binary-Regel:

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
)

Bei dieser Einrichtung kann Ihre kompilierte Binärdatei die GPU dynamisch laden und für die beschleunigte Inferenz für maschinelles Lernen verwenden.

GPU mit der CompiledModel API verwenden

Um den GPU-Beschleuniger zu verwenden, übergeben Sie den GPU-Parameter beim Erstellen des kompilierten Modells (CompiledModel). Das folgende Code-Snippet zeigt eine einfache Implementierung des gesamten Prozesses:

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

Weitere Informationen finden Sie in den Anleitungen Erste Schritte mit C++ oder Erste Schritte mit Kotlin.

Zero-Copy mit GPU-Beschleunigung

Durch die Verwendung von Zero-Copy kann eine GPU direkt auf Daten im eigenen Speicher zugreifen, ohne dass die CPU diese Daten explizit kopieren muss. Da keine Daten in den und aus dem CPU-Arbeitsspeicher kopiert werden, kann die End-to-End-Latenz durch Zero-Copy deutlich reduziert werden.

Der folgende Code ist ein Beispiel für die Implementierung von Zero-Copy-GPU mit OpenGL, einer API zum Rendern von Vektorgrafiken. Im Code werden Bilder im OpenGL-Pufferformat direkt an LiteRT übergeben:

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

Asynchrone Ausführung

Mit den asynchronen Methoden von LiteRT, z. B. RunAsync(), können Sie die GPU-Inferenz planen und gleichzeitig andere Aufgaben mit der CPU oder NPU ausführen. In komplexen Pipelines wird die GPU oft asynchron neben der CPU oder NPUs verwendet.

Das folgende Code-Snippet basiert auf dem Code im Beispiel GPU-Beschleunigung ohne Kopieren. Der Code verwendet sowohl CPU als auch GPU asynchron und hängt einen LiteRT-Event an den Eingabepuffer an. LiteRT Event ist für die Verwaltung verschiedener Arten von Synchronisierungsprimitiven zuständig. Mit dem folgenden Code wird ein verwaltetes LiteRT-Event-Objekt vom Typ LiteRtEventTypeEglSyncFence erstellt. Dieses Event-Objekt sorgt dafür, dass wir erst dann aus dem Eingabepuffer lesen, wenn die GPU fertig ist. All dies geschieht ohne Beteiligung der 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));

Unterstützte Modelle

LiteRT unterstützt die GPU-Beschleunigung mit den folgenden Modellen. Benchmark-Ergebnisse basieren auf Tests, die auf einem Samsung Galaxy S24 ausgeführt wurden.