Delegado de aceleração de GPU com a API Interpreter

Como usar unidades de processamento gráfico (GPUs) para executar modelos de machine learning (ML) pode melhorar drasticamente o desempenho e a experiência do usuário do seu os aplicativos habilitados para ML. Em dispositivos Android, é possível ativar delegate e uma das seguintes APIs:

  • API Interpreter - este guia
  • API nativa (C/C++): guia

Esta página descreve como ativar a aceleração de GPU para modelos LiteRT em Apps Android que usam a API Interpreter. Para mais informações sobre como usar a GPU da LiteRT, incluindo práticas recomendadas e técnicas avançadas, consulte a página de delegados de GPU.

Usar a GPU com o LiteRT com o Google Play Services

O intérprete do LiteRT API oferece um conjunto de APIs de uso geral para a criação de aplicativos de machine learning. Esta seção descreve como usar o delegado do acelerador de GPU com essas APIs com LiteRT com o Google Play Services.

LiteRT com Google Play Services é a opção recomendada para usar o LiteRT no Android. Caso seu aplicativo esteja direcionado a dispositivos ainda não executando o Google Play, consulte a GPU com API Interpreter e LiteRT.

Adicionar dependências do projeto (com o catálogo de versões .toml)

  1. Atualizar o arquivo libs.versions.toml do seu projeto
[libraries]
...
tflite-gpu = { module = "com.google.ai.edge.litert:litert-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "com.google.ai.edge.litert:litert-gpu-api", version = "2.X.Y" }
...
  1. Adicionar dependências do projeto no build.gradle.kts do app
dependencies {
  ...
  implementation(libraries.tflite.gpu)
  implementation(libraries.tflite.gpu.api)
  ...
}

Adicionar dependências do projeto

Para permitir o acesso ao delegado da GPU, adicione com.google.android.gms:play-services-tflite-gpu para o build.gradle do seu app arquivo:

dependencies {
    ...
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
}

Ativar aceleração de GPU

Em seguida, inicialize o LiteRT com o Google Play Services compatível com GPUs:

Kotlin

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

val interpreterTask = useGpuTask.continueWith { useGpuTask ->
  TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
      .setEnableGpuDelegateSupport(useGpuTask.result)
      .build())
  }

Java

Task<boolean> useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

Task<Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build());
});

Você pode finalmente inicializar o intérprete transmitindo um GpuDelegateFactory até InterpreterApi.Options:

Kotlin

    val options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(GpuDelegateFactory())

    val interpreter = InterpreterApi(model, options)

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

Java

    Options options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(new GpuDelegateFactory());

    Interpreter interpreter = new InterpreterApi(model, options);

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

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

Usar a GPU com o LiteRT independente

Caso seu aplicativo seja destinado a dispositivos que não executam o Google Play, ele é possível agrupar o delegado da GPU em seu aplicativo e usá-lo com o uma versão independente do LiteRT.

Adicionar dependências do projeto

Para permitir o acesso ao delegado da GPU, adicione com.google.ai.edge.litert:litert-gpu-delegate-plugin para o Arquivo build.gradle:

dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite'
    implementation 'com.google.ai.edge.litert:litert-gpu-delegate-plugin'
}

Ativar aceleração de GPU

Em seguida, execute o LiteRT na GPU com TfLiteDelegate. No Java, é possível especificar o GpuDelegate pelo 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);

Modelos quantizados

As bibliotecas de delegação de GPU do Android oferecem suporte a modelos quantizados por padrão. Você não precisará fazer alterações no código para usar modelos quantizados com o delegado da GPU. A seção a seguir explica como desativar o suporte quantizado para testes ou para fins experimentais.

Desativar o suporte a modelos quantizados

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

Java

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

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

Para mais informações sobre como executar modelos quantizados com aceleração de GPU, consulte Visão geral do delegado da GPU.