Accelerazione GPU con LiteRT

Le unità di elaborazione grafica (GPU) vengono comunemente utilizzate per l'accelerazione del deep learning grazie alla loro enorme velocità effettiva parallela rispetto alle CPU. LiteRT semplifica il processo di utilizzo dell'accelerazione GPU consentendo agli utenti di specificare l'accelerazione hardware come parametro durante la creazione di un modello compilato (CompiledModel).

Con l'accelerazione GPU di LiteRT, puoi creare buffer di input e output compatibili con la GPU, ottenere la copia zero con i tuoi dati nella memoria GPU ed eseguire attività in modo asincrono per massimizzare il parallelismo.

Per esempi di implementazioni della GPU LiteRT, consulta le seguenti applicazioni demo:

• Segmentazione delle immagini con Kotlin
• Segmentazione asincrona con C++

Aggiungere la dipendenza GPU

Segui questi passaggi per aggiungere la dipendenza GPU alla tua applicazione Kotlin o C++.

Kotlin

Per gli utenti Kotlin, l'acceleratore GPU è integrato e non richiede passaggi aggiuntivi oltre alla guida Guida introduttiva.

C++

Per gli utenti C++, devi creare le dipendenze dell'applicazione con l'accelerazione GPU LiteRT. La regola cc_binary che raggruppa la logica principale dell'applicazione (ad es. main.cc) richiede i seguenti componenti di runtime:

• Libreria condivisa dell'API LiteRT C: l'attributo data deve includere la libreria condivisa dell'API LiteRT C (//litert/c:litert_runtime_c_api_shared_lib) e i componenti specifici della GPU (@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so).
• Dipendenze degli attributi: l'attributo deps in genere include le dipendenze GLES gles_deps() e linkopts in genere include gles_linkopts(). Entrambi sono molto pertinenti per l'accelerazione GPU, poiché LiteRT spesso utilizza OpenGLES su Android.
• File del modello e altri asset: inclusi tramite l'attributo data.

Di seguito è riportato un esempio di regola 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
)

Questa configurazione consente al binario compilato di caricare e utilizzare dinamicamente la GPU per l'inferenza di machine learning accelerata.

Utilizzare la GPU con l'API CompiledModel

Per iniziare a utilizzare l'acceleratore GPU, trasmetti il parametro GPU durante la creazione del modello compilato (CompiledModel). Il seguente snippet di codice mostra un'implementazione di base dell'intero processo:

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

Per saperne di più, consulta le guide Guida introduttiva a C++ o Guida introduttiva a Kotlin.

Zero-copy con accelerazione GPU

L'utilizzo di zero-copy consente a una GPU di accedere direttamente ai dati nella propria memoria senza che la CPU debba copiarli esplicitamente. Non copiando i dati nella memoria della CPU e dalla memoria della CPU, la copia zero può ridurre significativamente la latenza end-to-end.

Il seguente codice è un'implementazione di esempio di Zero-Copy GPU con OpenGL, un'API per il rendering di grafica vettoriale. Il codice passa le immagini nel formato buffer OpenGL direttamente a 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());

Esecuzione asincrona

I metodi asincroni di LiteRT, come RunAsync(), ti consentono di pianificare l'inferenza della GPU mentre continui altre attività utilizzando la CPU o la NPU. Nelle pipeline complesse, la GPU viene spesso utilizzata in modo asincrono insieme alla CPU o alle NPU.

Il seguente snippet di codice si basa sul codice fornito nell'esempio di accelerazione GPU zero-copy. Il codice utilizza CPU e GPU in modo asincrono e collega un LiteRT Event al buffer di input. LiteRT Event è responsabile della gestione di diversi tipi di primitive di sincronizzazione e il seguente codice crea un oggetto evento LiteRT gestito di tipo LiteRtEventTypeEglSyncFence. Questo oggetto Event garantisce che non vengano letti dati dal buffer di input finché la GPU non ha terminato. Tutto questo viene fatto senza coinvolgere la 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));

Modelli supportati

LiteRT supporta l'accelerazione GPU con i seguenti modelli. I risultati del benchmark si basano su test eseguiti su un dispositivo Samsung Galaxy S24.