Delegado de aceleración de GPU con la API de intérprete

El uso de unidades de procesamiento gráfico (GPU) para ejecutar tus modelos de aprendizaje automático (AA) puede mejorar drásticamente el rendimiento y la experiencia del usuario de las aplicaciones habilitadas para el AA. En dispositivos Android, puedes habilitar un delegado y una de las siguientes APIs:

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

En esta página, se describe cómo habilitar la aceleración de GPU para modelos de TensorFlow Lite en apps para Android que usan la API de intérprete. Para obtener más información sobre el uso del delegado de GPU para TensorFlow Lite, incluidas las prácticas recomendadas y las técnicas avanzadas, consulta la página Delegados de GPU.

Usa GPU con TensorFlow Lite con los Servicios de Google Play

La API de Interpreter de TensorFlow Lite proporciona un conjunto de API de uso general para compilar aplicaciones de aprendizaje automático. En esta sección, se describe cómo usar el delegado del acelerador de GPU con estas APIs en TensorFlow Lite con los Servicios de Google Play.

TensorFlow Lite con los Servicios de Google Play es la ruta recomendada para usar TensorFlow Lite en Android. Si tu aplicación está orientada a dispositivos que no ejecutan Google Play, consulta la sección GPU con la API de intérprete y TensorFlow Lite independiente.

Agrega dependencias del proyecto (con un catálogo de versiones en .toml)

1. Actualiza el archivo libs.versions.toml de tu proyecto

[libraries]
...
tflite-gpu = { module = "org.tensorflow:tensorflow-lite-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "org.tensorflow:tensorflow-lite-gpu-api", version = "2.X.Y" }
...

1. Agrega dependencias de proyecto en el build.gradle.kts de la app

dependencies {
  ...
  implementation(libraries.tflite.gpu)
  implementation(libraries.tflite.gpu.api)
  ...
}

Agrega dependencias del proyecto

Para habilitar el acceso al delegado de la GPU, agrega com.google.android.gms:play-services-tflite-gpu al archivo build.gradle de tu app:

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

Cómo habilitar la aceleración de GPU

Luego, inicializa TensorFlow Lite con los Servicios de Google Play compatibles con GPU:

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

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

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

Por último, puedes inicializar el intérprete pasando un GpuDelegateFactory a través de InterpreterApi.Options:

    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)
      

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

El delegado de la GPU también se puede usar con la vinculación de modelos de AA en Android Studio. Para obtener más información, consulta Cómo generar interfaces de modelos con metadatos.

Usa GPU con TensorFlow Lite independiente

Si tu aplicación se orienta a dispositivos que no ejecutan Google Play, es posible empaquetar el delegado de la GPU a tu aplicación y usarlo con la versión independiente de TensorFlow Lite.

Agrega dependencias del proyecto

Para habilitar el acceso al delegado de la GPU, agrega org.tensorflow:tensorflow-lite-gpu-delegate-plugin al archivo build.gradle de tu app:

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

Cómo habilitar la aceleración de GPU

Luego, ejecuta TensorFlow Lite en la GPU con TfLiteDelegate. En Java, puedes especificar GpuDelegate a Interpreter.Options.

      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)
      

      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 cuantificados

Las bibliotecas delegadas de GPU de Android admiten modelos cuantificados de forma predeterminada. No es necesario que realices ningún cambio en el código para usar modelos cuantizados con el delegado de GPU. En la siguiente sección, se explica cómo inhabilitar la compatibilidad cuantizada con fines experimentales o de prueba.

Inhabilita la compatibilidad con modelos cuantizados

En el siguiente código, se muestra cómo inhabilitar la compatibilidad con modelos cuantizados.

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

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

Para obtener más información sobre cómo ejecutar modelos cuantizados con aceleración de GPU, consulta la descripción general del delegado de GPU.