Delegato dell'accelerazione GPU con API Interpreter

L'utilizzo di unità di elaborazione grafica (GPU) per eseguire i modelli di machine learning (ML) può migliorare notevolmente le prestazioni e l'esperienza utente delle tue applicazioni abilitate per ML. Sui dispositivi Android è possibile abilitare

delegato e una delle seguenti API:

  • API interprete: questa guida
  • API della libreria attività - guida
  • API nativa (C/C++) - guida

Questa pagina descrive come abilitare l'accelerazione GPU per i modelli TensorFlow Lite nelle app Android utilizzando l'API Interpreter. Per ulteriori informazioni sull'utilizzo del delegato GPU per TensorFlow Lite, incluse best practice e tecniche avanzate, consulta la pagina dei delegati GPU .

Utilizza GPU con TensorFlow Lite con i servizi Google Play

L' API TensorFlow Lite Interpreter fornisce una serie di API generiche per la creazione di applicazioni di machine learning. Questa sezione descrive come utilizzare il delegato dell'acceleratore GPU con queste API con TensorFlow Lite con i servizi Google Play.

TensorFlow Lite con i servizi Google Play è il percorso consigliato per utilizzare TensorFlow Lite su Android. Se la tua applicazione è destinata a dispositivi che non eseguono Google Play, consulta la sezione GPU con API Interpreter e TensorFlow Lite autonomo .

Aggiungi dipendenze del progetto

Per abilitare l'accesso al delegato GPU, aggiungi com.google.android.gms:play-services-tflite-gpu al file build.gradle della tua 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'
}

Abilita l'accelerazione GPU

Quindi inizializza TensorFlow Lite con i servizi Google Play con il supporto GPU:

Kotlin

    val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Giava

    Task useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

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

Puoi finalmente inizializzare l'interprete passando una GpuDelegateFactory tramite 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)
      

Giava


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

Il delegato GPU può essere utilizzato anche con l'associazione di modelli ML in Android Studio. Per ulteriori informazioni, consulta Generare interfacce di modelli utilizzando i metadati .

Utilizza la GPU con TensorFlow Lite autonomo

Se la tua applicazione è destinata a dispositivi che non eseguono Google Play, è possibile raggruppare il delegato GPU nella tua applicazione e utilizzarlo con la versione standalone di TensorFlow Lite.

Aggiungi dipendenze del progetto

Per abilitare l'accesso al delegato GPU, aggiungi org.tensorflow:tensorflow-lite-gpu-delegate-plugin al file build.gradle della tua app:

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

Abilita l'accelerazione GPU

Quindi esegui TensorFlow Lite su GPU con TfLiteDelegate . In Java, è possibile specificare GpuDelegate tramite 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)
      

Giava

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

Modelli quantizzati

Le librerie dei delegati GPU Android supportano i modelli quantizzati per impostazione predefinita. Non è necessario apportare modifiche al codice per utilizzare modelli quantizzati con il delegato GPU. La sezione seguente spiega come disabilitare il supporto quantizzato per scopi di test o sperimentali.

Disabilita il supporto del modello quantizzato

Il codice seguente mostra come disabilitare il supporto per i modelli quantizzati.

Giava

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

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

Per ulteriori informazioni sull'esecuzione di modelli quantizzati con accelerazione GPU, vedere Panoramica del delegato GPU .