Delegado de aceleração de GPU com API C/C++

O uso de unidades de processamento gráfico (GPUs) para executar seus modelos de aprendizado de máquina (ML) pode melhorar drasticamente o desempenho e a experiência do usuário de seus aplicativos habilitados para ML. Em dispositivos Android, você pode ativar a execução acelerada por GPU dos seus modelos usando um delegado e uma das seguintes APIs:

  • API de intérprete - guia
  • API da biblioteca de tarefas – guia
  • API nativa (C/C++) – este guia

Este guia aborda usos avançados do delegado de GPU para API C, API C++ e uso de modelos quantizados. Para obter mais informações sobre como usar o delegado de GPU para TensorFlow Lite, incluindo práticas recomendadas e técnicas avançadas, consulte a página de delegados de GPU .

Habilitar aceleração de GPU

Use o delegado de GPU do TensorFlow Lite para Android em C ou C++ criando o delegado com TfLiteGpuDelegateV2Create() e destruindo-o com TfLiteGpuDelegateV2Delete() , conforme mostrado no código de exemplo a seguir:

// 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 o código do objeto TfLiteGpuDelegateOptionsV2 para criar uma instância delegada com opções personalizadas. Você pode inicializar as opções padrão com TfLiteGpuDelegateOptionsV2Default() e depois modificá-las conforme necessário.

O delegado de GPU do TensorFlow Lite para Android em C ou C++ usa o sistema de compilação Bazel . Você pode construir o delegado usando o seguinte 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

Ao chamar Interpreter::ModifyGraphWithDelegate() ou Interpreter::Invoke() , o chamador deve ter um EGLContext no thread atual e Interpreter::Invoke() deve ser chamado do mesmo EGLContext . Se um EGLContext não existir, o delegado criará um internamente, mas você deverá garantir que Interpreter::Invoke() seja sempre chamado a partir do mesmo thread em que Interpreter::ModifyGraphWithDelegate() foi chamado.

Com o TensorFlow Lite no Google Play Services:

Se você estiver usando o TensorFlow Lite na API C do Google Play Services, precisará usar a API Java/Kotlin para verificar se um delegado de GPU está disponível para seu dispositivo antes de inicializar o tempo de execução do TensorFlow Lite.

Adicione as dependências gradle do delegado da GPU ao seu aplicativo:

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

Em seguida, verifique a disponibilidade da GPU e inicialize o TfLiteNative se a verificação for bem-sucedida:

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

Você também precisa atualizar sua configuração do CMake para incluir o sinalizador do compilador TFLITE_USE_OPAQUE_DELEGATE :

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

A biblioteca FlatBuffers é usada para configurar plugins delegados, então você precisa adicioná-la às dependências do seu código nativo. Você pode usar a configuração oficial do projeto CMake da seguinte forma:

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

Você também pode simplesmente agrupar os cabeçalhos em seu aplicativo.

Finalmente, para usar a inferência de GPU em seu código C, crie o 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 quantizados

As bibliotecas delegadas de GPU do Android oferecem suporte a modelos quantizados por padrão. Você não precisa fazer nenhuma alteração no código para usar modelos quantizados com o delegado da GPU. A seção a seguir explica como desabilitar o suporte quantizado para fins de teste ou experimentais.

Desativar suporte a modelo quantizado

O código a seguir mostra como desabilitar o suporte para modelos quantizados.

C++

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

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

Para obter mais informações sobre a execução de modelos quantizados com aceleração de GPU, consulte Visão geral do delegado de GPU .