Participe do Simpósio Women in ML em 7 de dezembro Inscreva-se agora

Delegado de aceleração de GPU para Android

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

O uso de unidades de processamento gráfico (GPUs) para executar seus modelos de aprendizado de máquina (ML) pode melhorar drasticamente o desempenho de seu modelo e a experiência do usuário de seus aplicativos habilitados para ML. Em dispositivos Android, você pode ativar o uso da execução acelerada por GPU de seus modelos usando um delegado . Os delegados atuam como drivers de hardware para o TensorFlow Lite, permitindo que você execute o código do seu modelo em processadores GPU.

Esta página descreve como habilitar a aceleração de GPU para modelos do TensorFlow Lite em aplicativos Android. Para obter mais informações sobre como usar o delegado de GPU para o TensorFlow Lite, incluindo práticas recomendadas e técnicas avançadas, consulte a página de delegados de GPU .

Use GPU com APIs de biblioteca de tarefas

As bibliotecas de tarefas do TensorFlow Lite fornecem um conjunto de APIs específicas de tarefas para criar aplicativos de aprendizado de máquina. Esta seção descreve como usar o delegado do acelerador de GPU com essas APIs.

Adicionar dependências do projeto

Habilite o acesso às APIs delegadas da GPU com as bibliotecas de tarefas do TensorFlow Lite adicionando as seguintes dependências, atualize o arquivo build.gradle de seus projetos de desenvolvimento para incluir o tensorflow-lite-gpu-delegate-plugin , conforme mostrado no exemplo de código a seguir:

dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Ativar aceleração de GPU

Habilite a opção de delegado de GPU para sua classe de modelo de API de tarefas com a classe BaseOptions . Por exemplo, você pode configurar a GPU no ObjectDetector conforme mostrado nos exemplos de código a seguir:

Kotlin

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    val baseOptions = BaseOptions.builder().useGpu().build()

    val options =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options)

      

Java

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options);
      

Usar GPU com API de intérprete

A API do TensorFlow Lite Interpreter fornece um conjunto de APIs de uso geral para criar aplicativos de aprendizado de máquina. Esta seção descreve como usar o delegado do acelerador de GPU com essas APIs.

Adicionar dependências do projeto

Habilite o acesso às APIs delegadas da GPU adicionando as seguintes dependências, atualize o arquivo build.gradle de seus projetos de desenvolvimento para incluir o org.tensorflow:tensorflow-lite-gpu , conforme mostrado no exemplo de código a seguir:

dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite'
    implementation 'org.tensorflow:tensorflow-lite-gpu'
}

Ativar aceleração de GPU

Em seguida, execute o TensorFlow Lite na GPU com TfLiteDelegate . Em Java, você pode especificar o GpuDelegate por meio de Interpreter.Options .

Kotlin

    import org.tensorflow.lite.Interpreter
    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = Interpreter.Options().apply{
        if(compatList.isDelegateSupportedOnThisDevice){
            // if the device has a supported GPU, add the GPU delegate
            val delegateOptions = compatList.bestOptionsForThisDevice
            this.addDelegate(GpuDelegate(delegateOptions))
        } else {
            // if the GPU is not supported, run on 4 threads
            this.setNumThreads(4)
        }
    }

    val interpreter = Interpreter(model, options)

    // Run inference
    writeToInput(input)
    interpreter.run(input, output)
    readFromOutput(output)
      

Java

    import org.tensorflow.lite.Interpreter;
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Interpreter.Options options = new Interpreter.Options();
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        GpuDelegate.Options delegateOptions = compatList.getBestOptionsForThisDevice();
        GpuDelegate gpuDelegate = new GpuDelegate(delegateOptions);
        options.addDelegate(gpuDelegate);
    } else {
        // if the GPU is not supported, run on 4 threads
        options.setNumThreads(4);
    }

    Interpreter interpreter = new Interpreter(model, options);

    // Run inference
    writeToInput(input);
    interpreter.run(input, output);
    readFromOutput(output);
      

O delegado de GPU também pode ser usado com vinculação de modelo de ML no Android Studio. Para obter mais informações, consulte Gerar interfaces de modelo usando metadados .

Suporte avançado de GPU

Esta seção abrange os usos avançados do delegado de GPU para Android, incluindo a API C, a API C++ e o uso de modelos quantizados.

API C/C++ para Android

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 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 encadeamento atual e Interpreter::Invoke() deve ser chamado a partir do mesmo EGLContext . Se um EGLContext não existir, o delegado criará um internamente, mas você deverá assegurar que Interpreter::Invoke() seja sempre chamado a partir do mesmo encadeamento no qual Interpreter::ModifyGraphWithDelegate() foi chamado.

Modelos quantizados

As bibliotecas delegadas da GPU Android são compatíveis com 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 modelos quantizados

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

Java

GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false));

Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
      

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 .