Delegado de aceleración de GPU con API C/C++

El uso de unidades de procesamiento de gráficos (GPU) para ejecutar sus modelos de aprendizaje automático (ML) puede mejorar drásticamente el rendimiento y la experiencia del usuario de sus aplicaciones habilitadas para ML. En dispositivos Android, puede habilitar la ejecución acelerada por GPU de sus modelos mediante un delegado y una de las siguientes API:

  • API de intérprete - guía
  • API de biblioteca de tareas: guía
  • API nativa (C/C++): esta guía

Esta guía cubre usos avanzados del delegado de GPU para C API, C++ API y el uso de modelos cuantificados. Para obtener más información sobre el uso del delegado de GPU para TensorFlow Lite, incluidas las mejores prácticas y técnicas avanzadas, consulte la página de delegados de GPU .

Habilitar la aceleración de GPU

Utilice el delegado de GPU de TensorFlow Lite para Android en C o C++ creando el delegado con TfLiteGpuDelegateV2Create() y destruyéndolo con TfLiteGpuDelegateV2Delete() , como se muestra en el siguiente código de ejemplo:

// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);

// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));

// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);

Revise el código objeto TfLiteGpuDelegateOptionsV2 para crear una instancia delegada con opciones personalizadas. Puede inicializar las opciones predeterminadas con TfLiteGpuDelegateOptionsV2Default() y luego modificarlas según sea necesario.

El delegado de GPU de TensorFlow Lite para Android en C o C++ utiliza el sistema de compilación Bazel . Puede crear el delegado usando el siguiente comando:

bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate                           # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so  # for dynamic library

Al llamar a Interpreter::ModifyGraphWithDelegate() o Interpreter::Invoke() , la persona que llama debe tener un EGLContext en el hilo actual y se debe llamar a Interpreter::Invoke() desde el mismo EGLContext . Si no existe un EGLContext , el delegado crea uno internamente, pero luego debe asegurarse de que Interpreter::Invoke() siempre se llame desde el mismo hilo en el que se llamó a Interpreter::ModifyGraphWithDelegate() .

Con TensorFlow Lite en los servicios de Google Play:

Si está utilizando TensorFlow Lite en la API C de Google Play Services, deberá usar la API de Java/Kotlin para verificar si hay un delegado de GPU disponible para su dispositivo antes de inicializar el tiempo de ejecución de TensorFlow Lite.

Agregue las dependencias de gradle delegado de GPU a su aplicación:

implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

Luego, verifique la disponibilidad de la GPU e inicialice TfLiteNative si la verificación es exitosa:

Java

Task tfLiteHandleTask =
TfLiteGpu.isGpuDelegateAvailable(this)
   .onSuccessTask(gpuAvailable -> {
      TfLiteInitializationOptions options =
        TfLiteInitializationOptions.builder()
          .setEnableGpuDelegateSupport(gpuAvailable).build();
        return TfLiteNative.initialize(this, options);
      }
    );

Kotlin

val tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this)
    .onSuccessTask { gpuAvailable ->
        val options = TfLiteInitializationOptions.Builder()
            .setEnableGpuDelegateSupport(gpuAvailable)
            .build()
        TfLiteNative.initialize(this, options)
    }

También necesita actualizar su configuración de CMake para incluir el indicador del compilador TFLITE_USE_OPAQUE_DELEGATE :

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

La biblioteca FlatBuffers se utiliza para configurar complementos delegados, por lo que debes agregarla a las dependencias de tu código nativo. Puede utilizar la configuración oficial del proyecto CMake de la siguiente manera:

target_include_directories(tflite-jni PUBLIC
        third_party/headers # flatbuffers
     ...)

También puedes simplemente agrupar los encabezados en tu aplicación.

Finalmente, para usar la inferencia de GPU en su código C, cree el delegado de GPU usando TFLiteSettings :

#include "flatbuffers/flatbuffers.h"
#include "tensorflow/lite/acceleration/configuration/configuration_generated.h"

flatbuffers::FlatBufferBuilder fbb;
tflite::TFLiteSettingsBuilder builder(fbb);
const tflite::TFLiteSettings* tflite_settings =
    flatbuffers::GetTemporaryPointer(fbb, builder.Finish());

const TfLiteOpaqueDelegatePlugin* pluginCApi = TfLiteGpuDelegatePluginCApi();
TfLiteOpaqueDelegate* gpu_delegate = pluginCApi->create(tflite_settings);

Modelos cuantificados

Las bibliotecas delegadas de GPU de Android admiten modelos cuantificados de forma predeterminada. No es necesario realizar ningún cambio de código para utilizar modelos cuantificados con el delegado de GPU. La siguiente sección explica cómo desactivar el soporte cuantificado para fines experimentales o de prueba.

Deshabilitar la compatibilidad con modelos cuantificados

El siguiente código muestra cómo deshabilitar la compatibilidad con modelos cuantificados.

C++

TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE;

auto* delegate = TfLiteGpuDelegateV2Create(options);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

Para obtener más información sobre la ejecución de modelos cuantificados con aceleración de GPU, consulte Descripción general del delegado de GPU .