Delegado de aceleración de GPU con Interpreter API

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 los dispositivos Android, puede habilitar

delegado y una de las siguientes API:

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

En esta página, se describe cómo habilitar la aceleración de GPU para modelos TensorFlow Lite en aplicaciones de Android mediante 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, consulte la página de delegados de GPU .

Use GPU con TensorFlow Lite con los servicios de Google Play

La API de intérprete de TensorFlow Lite proporciona un conjunto de API de uso general para crear aplicaciones de aprendizaje automático. En esta sección, se describe cómo usar el delegado del acelerador de GPU con estas API con 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 su aplicación está dirigida a dispositivos que no ejecutan Google Play, consulte la sección GPU con API de intérprete y TensorFlow Lite independiente .

Agregar dependencias del proyecto

Para habilitar el acceso al delegado de GPU, agregue com.google.android.gms:play-services-tflite-gpu al archivo build.gradle de su aplicación:

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

Habilitar la aceleración de GPU

Luego, inicialice TensorFlow Lite con los servicios de Google Play con soporte para GPU:

kotlin

    val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Java

    Task useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

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

Finalmente puede inicializar el intérprete pasando un GpuDelegateFactory a través de 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);
      

El delegado de GPU también se puede usar con el enlace de modelos ML en Android Studio. Para obtener más información, consulte Generar interfaces de modelo mediante metadatos .

Usar GPU con TensorFlow Lite independiente

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

Agregar dependencias del proyecto

Para habilitar el acceso al delegado de GPU, agregue org.tensorflow:tensorflow-lite-gpu-delegate-plugin al archivo build.gradle de su aplicación:

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

Habilitar la aceleración de GPU

Luego ejecute TensorFlow Lite en GPU con TfLiteDelegate . En Java, puede especificar el GpuDelegate a través 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);
      

modelos cuantificados

Las bibliotecas de delegados de GPU de Android admiten modelos cuantificados de forma predeterminada. No tiene que realizar ningún cambio de código para usar modelos cuantificados con el delegado de GPU. La siguiente sección explica cómo deshabilitar el soporte cuantificado para fines de prueba o experimentales.

Deshabilitar el soporte de modelo cuantificado

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

Java

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 cuantificados con aceleración de GPU, consulte Información general sobre delegados de GPU .