GPU-Beschleunigung mit LiteRT Next

Grafikprozessoren (GPUs) werden aufgrund ihres enormen parallelen Durchsatzes im Vergleich zu CPUs häufig für die Beschleunigung von Deep Learning verwendet. LiteRT Next vereinfacht die Verwendung der GPU-Beschleunigung, da Nutzer die Hardwarebeschleunigung beim Erstellen eines kompilierten Modells (CompiledModel) als Parameter angeben können. LiteRT Next verwendet außerdem eine neue und verbesserte GPU-Beschleunigungsimplementierung, die von LiteRT nicht angeboten wird.

Mit der GPU-Beschleunigung von LiteRT Next können Sie GPU-freundliche Eingabe- und Ausgabe-Buffer erstellen, Zero-Copy-Datenübertragungen im GPU-Speicher erzielen und Aufgaben asynchron ausführen, um die Parallelität zu maximieren.

Beispielimplementierungen von LiteRT Next mit GPU-Unterstützung finden Sie in den folgenden Demoanwendungen:

• Bildsegmentierung mit Kotlin
• Asynchrone Segmentierung mit C++

GPU-Abhängigkeit hinzufügen

So fügen Sie Ihrer Kotlin- oder C++-Anwendung eine GPU-Abhängigkeit hinzu:

Kotlin

Für Kotlin-Nutzer ist der GPU-Accelerator bereits integriert und es sind keine zusätzlichen Schritte erforderlich, die über die Einstiegsanleitung hinausgehen.

C++

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

• LiteRT C API-Bibliothek: Das Attribut data muss die LiteRT C API-Bibliothek (//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 relevant, da LiteRT unter Android häufig OpenGLES verwendet.
• Modelldateien und andere Assets: Über das Attribut data eingeschlossen.

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
)

Mit dieser Einrichtung kann die GPU für die beschleunigte Inferenz beim maschinellen Lernen dynamisch geladen und verwendet werden.

Jetzt starten

Wenn Sie den GPU-Beschleuniger verwenden möchten, geben Sie den GPU-Parameter beim Erstellen des kompilierten Modells (CompiledModel) an. Das folgende Code-Snippet zeigt eine grundlegende 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.

LiteRT Next GPU Accelerator

Der neue GPU-Accelerator, der nur mit LiteRT Next verfügbar ist, ist für die effizientere Verarbeitung von KI-Arbeitslasten wie großen Matrixmultiplikationen und KV-Cache für LLMs optimiert als frühere Versionen. Der LiteRT Next-GPU-Beschleuniger bietet im Vergleich zur LiteRT-Version folgende wichtige Verbesserungen:

• Erweiterte Abdeckung von Mobilfunkanbietern:Unterstützung größerer, komplexerer neuronaler Netzwerke.
• Verbesserte Interoperabilität von Buffers:GPU-Buffers können jetzt direkt für Kameraframes, 2D-Texturen oder große LLM-Zustände verwendet werden.
• Unterstützung für die asynchrone Ausführung:Überlappen Sie die CPU-Vorverarbeitung mit der GPU-Inferenz.

Zero-Copy mit GPU-Beschleunigung

Mit Zero-Copy kann eine GPU direkt auf Daten in ihrem eigenen Arbeitsspeicher zugreifen, ohne dass die CPU diese Daten explizit kopieren muss. Da bei der Zero-Copy-Technologie keine Daten in den und aus dem CPU-Speicher kopiert werden, kann die End-to-End-Latenz deutlich reduziert werden.

Der folgende Code ist eine Beispielimplementierung der Zero-Copy-GPU mit OpenGL, einer API zum Rendern von Vektorgrafiken. Der Code übergibt Bilder im OpenGL-Pufferformat direkt an LiteRT Next:

// 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 wie RunAsync() können Sie GPU-Inferenzen planen und gleichzeitig andere Aufgaben mit der CPU oder der NPU ausführen. In komplexen Pipelines werden GPUs oft asynchron neben CPUs oder NPUs verwendet.

Das folgende Code-Snippet basiert auf dem Code im Beispiel GPU-Beschleunigung ohne Kopiervorgang. Der Code verwendet sowohl die CPU als auch die GPU asynchron und hängt dem Eingabebuffer eine LiteRT-Event an. LiteRT Event ist für die Verwaltung verschiedener Arten von Synchronisierungsprimitiven verantwortlich. Mit dem folgenden Code wird ein verwaltetes LiteRT-Ereignisobjekt vom Typ LiteRtEventTypeEglSyncFence erstellt. Dieses Event-Objekt sorgt dafür, dass erst gelesen wird, wenn die GPU fertig ist. All dies geschieht ohne Einbindung 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 Next unterstützt die GPU-Beschleunigung mit den folgenden Modellen. Die Benchmark-Ergebnisse basieren auf Tests, die auf einem Samsung Galaxy S24 durchgeführt wurden.