Accélération GPU avec LiteRT

Les processeurs graphiques (GPU) sont couramment utilisés pour accélérer le deep learning en raison de leur débit parallèle massif par rapport aux processeurs. LiteRT simplifie l'utilisation de l'accélération GPU en permettant aux utilisateurs de spécifier l'accélération matérielle en tant que paramètre lors de la création d'un modèle compilé (CompiledModel).

Grâce à l'accélération GPU de LiteRT, vous pouvez créer des tampons d'entrée et de sortie compatibles avec les GPU, obtenir une copie zéro avec vos données dans la mémoire GPU et exécuter des tâches de manière asynchrone pour maximiser le parallélisme.

Pour obtenir des exemples d'implémentations de LiteRT GPU, consultez les applications de démonstration suivantes :

• Segmentation d'images avec Kotlin
• Segmentation asynchrone avec C++

Ajouter une dépendance GPU

Suivez les étapes ci-dessous pour ajouter une dépendance GPU à votre application Kotlin ou C++.

Kotlin

Pour les utilisateurs de Kotlin, l'accélérateur GPU est intégré et ne nécessite aucune étape supplémentaire au-delà du guide Premiers pas.

C++

Pour les utilisateurs de C++, vous devez créer les dépendances de l'application avec l'accélération GPU LiteRT. La règle cc_binary qui regroupe la logique d'application principale (par exemple, main.cc) nécessite les composants d'exécution suivants :

• Bibliothèque partagée de l'API LiteRT C : l'attribut data doit inclure la bibliothèque partagée de l'API LiteRT C (//litert/c:litert_runtime_c_api_shared_lib) et les composants spécifiques au GPU (@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so).
• Dépendances des attributs : l'attribut deps inclut généralement les dépendances GLES gles_deps(), et linkopts inclut généralement gles_linkopts(). Les deux sont très pertinents pour l'accélération GPU, car LiteRT utilise souvent OpenGLES sur Android.
• Fichiers de modèle et autres composants : inclus via l'attribut data.

Voici un exemple de règle 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
)

Cette configuration permet à votre binaire compilé de charger et d'utiliser dynamiquement le GPU pour l'inférence de machine learning accélérée.

Utiliser un GPU avec l'API CompiledModel

Pour commencer à utiliser l'accélérateur GPU, transmettez le paramètre GPU lors de la création du modèle compilé (CompiledModel). L'extrait de code suivant montre une implémentation de base de l'ensemble du processus :

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

Pour en savoir plus, consultez les guides Premiers pas avec C++ ou Premiers pas avec Kotlin.

Sans copie avec accélération GPU

L'utilisation de la copie zéro permet à un GPU d'accéder directement aux données dans sa propre mémoire sans que le CPU ait besoin de copier explicitement ces données. En évitant de copier les données vers et depuis la mémoire du processeur, la copie zéro peut réduire considérablement la latence de bout en bout.

Le code suivant est un exemple d'implémentation de GPU sans copie avec OpenGL, une API pour le rendu de graphiques vectoriels. Le code transmet les images au format de tampon OpenGL directement à 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());

Exécution asynchrone

Les méthodes asynchrones de LiteRT, comme RunAsync(), vous permettent de planifier l'inférence GPU tout en poursuivant d'autres tâches à l'aide du CPU ou de la NPU. Dans les pipelines complexes, le GPU est souvent utilisé de manière asynchrone aux côtés du CPU ou des NPU.

L'extrait de code suivant s'appuie sur le code fourni dans l'exemple Accélération GPU sans copie. Le code utilise le CPU et le GPU de manière asynchrone, et associe un Event LiteRT au tampon d'entrée. LiteRT Event est responsable de la gestion de différents types de primitives de synchronisation. Le code suivant crée un objet LiteRT Event géré de type LiteRtEventTypeEglSyncFence. Cet objet Event garantit que nous ne lisons pas à partir du tampon d'entrée tant que le GPU n'a pas terminé. Tout cela se fait sans impliquer le processeur.

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

Modèles compatibles

LiteRT est compatible avec l'accélération GPU avec les modèles suivants. Les résultats des tests comparatifs sont basés sur des tests exécutés sur un appareil Samsung Galaxy S24.