GPU-Beschleunigungsdelegat mit Interpreter API

Die Verwendung von Grafikprozessoren (GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) kann die Leistung und Nutzerfreundlichkeit Ihrer ML-fähigen Anwendungen erheblich verbessern. Auf Android-Geräten können Sie einen Bevollmächtigten und eine der folgenden APIs aktivieren:

• Interpreter API – dieser Leitfaden
• Native API (C/C++) – Anleitung

Auf dieser Seite wird beschrieben, wie Sie die GPU-Beschleunigung für TensorFlow Lite-Modelle in Android-Apps mithilfe der Interpreter API aktivieren. Weitere Informationen zur Verwendung des GPU-Bevollmächtigten für TensorFlow Lite, einschließlich Best Practices und erweiterter Techniken, finden Sie auf der Seite GPU-Bevollmächtigte.

GPU mit TensorFlow Lite mit Google Play-Diensten verwenden

Die Interpreter API von TensorFlow Lite bietet eine Reihe von allgemeinen APIs zum Erstellen von Anwendungen für maschinelles Lernen. In diesem Abschnitt wird beschrieben, wie Sie den GPU-Beschleuniger-Delegaten mit diesen APIs in TensorFlow Lite mit Google Play-Diensten verwenden.

TensorFlow Lite mit Google Play-Diensten ist der empfohlene Pfad für die Verwendung von TensorFlow Lite unter Android. Wenn Ihre App auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, lesen Sie den Abschnitt GPU mit Interpreter API und eigenständigem TensorFlow Lite.

Projektabhängigkeiten hinzufügen (mit .toml-Versionskatalog)

1. libs.versions.toml-Datei Ihres Projekts aktualisieren

[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. Projektabhängigkeiten in der build.gradle.kts der Anwendung hinzufügen

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

Projektabhängigkeiten hinzufügen

Fügen Sie der Datei build.gradle Ihrer Anwendung com.google.android.gms:play-services-tflite-gpu hinzu, um den Zugriff auf den GPU-Delegaten zu aktivieren:

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

GPU-Beschleunigung aktivieren

Initialisieren Sie dann TensorFlow Lite mit den Google Play-Diensten mit der GPU-Unterstützung:

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

Sie können den Interpreter initialisieren und GpuDelegateFactory über InterpreterApi.Options übergeben:

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

Der GPU-Delegate kann auch mit ML-Modellbindung in Android Studio verwendet werden. Weitere Informationen finden Sie unter Modellschnittstellen mit Metadaten generieren.

GPU mit eigenständigem TensorFlow Lite verwenden

Wenn Ihre Anwendung auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, ist es möglich, den GPU-Delegaten zu Ihrer Anwendung zu bündeln und mit der eigenständigen Version von TensorFlow Lite zu verwenden.

Projektabhängigkeiten hinzufügen

Fügen Sie der Datei build.gradle Ihrer Anwendung org.tensorflow:tensorflow-lite-gpu-delegate-plugin hinzu, um den Zugriff auf den GPU-Delegaten zu aktivieren:

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

GPU-Beschleunigung aktivieren

Führen Sie dann TensorFlow Lite mit TfLiteDelegate auf der GPU aus. In Java können Sie GpuDelegate bis Interpreter.Options angeben.

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

Quantisierte Modelle

Android-GPU-Delegierungsbibliotheken unterstützen standardmäßig quantisierte Modelle. Sie müssen keine Codeänderungen vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Test- oder experimentelle Zwecke deaktivieren.

Unterstützung quantisierter Modelle deaktivieren

Der folgende Code zeigt, wie Sie die Unterstützung für quantisierte Modelle deaktivieren.

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

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

Weitere Informationen zum Ausführen quantisierter Modelle mit GPU-Beschleunigung finden Sie in der Übersicht zum GPU-Delegaten.