GPU-Beschleunigungsdelegat mit Interpreter API

Grafikprozessoren (Graphics Processing Units, GPUs) zum Ausführen Ihrer Modelle für maschinelles Lernen (ML) verwenden die Leistung und Nutzererfahrung Ihrer Anzeigen erheblich verbessern, ML-fähige Anwendungen Auf Android-Geräten können Sie delegate und eine der folgenden APIs:

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

Auf dieser Seite wird beschrieben, wie Sie die GPU-Beschleunigung für LiteRT-Modelle in Android-Apps, die die Interpreter API verwenden Weitere Informationen zur Verwendung der GPU an LiteRT delegieren, einschließlich Best Practices und fortgeschrittener Techniken, Weitere Informationen finden Sie auf der Seite GPU-Bevollmächtigte.

GPU mit LiteRT mit Google Play-Diensten verwenden

Der LiteRT-Interpreter API bietet eine Reihe von universelle APIs zum Erstellen von ML-Anwendungen entwickelt. Dieser Abschnitt wird beschrieben, wie Sie den GPU-Beschleunigerdelegat mit diesen APIs LiteRT mit Google Play-Diensten

Wir empfehlen LiteRT mit Google Play-Diensten zu verwenden. LiteRT unter Android nutzen. Wenn Ihre App auf Geräte ausgerichtet ist Google Play nicht ausführen, sehen Sie sich die GPU mit Interpreter API und der eigenständigen LiteRT lesen.

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

1. Datei libs.versions.toml Ihres Projekts aktualisieren

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

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

Projektabhängigkeiten hinzufügen

Fügen Sie zum Aktivieren des Zugriffs auf den GPU-Delegaten com.google.android.gms:play-services-tflite-gpu zu build.gradle deiner App Datei:

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 LiteRT mit den Google Play-Diensten mit 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());
});
        

Schließlich können Sie den Interpreter initialisieren, indem Sie GpuDelegateFactory übergeben. bis 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);
      

Der GPU-Delegate kann auch mit ML-Modellbindung in Android Studio verwendet werden. Für Weitere Informationen finden Sie unter Generieren von Modellschnittstellen mit Metadaten.

GPU mit eigenständigem LiteRT verwenden

Wenn Ihre App auf Geräte ausgerichtet ist, auf denen Google Play nicht ausgeführt wird, den GPU-Delegaten für Ihre Anwendung zu bündeln und mit dem LiteRT-Version.

Projektabhängigkeiten hinzufügen

Fügen Sie zum Aktivieren des Zugriffs auf den GPU-Delegaten com.google.ai.edge.litert:litert-gpu-delegate-plugin zu deiner App build.gradle-Datei:

dependencies {
    ...
    implementation 'com.google.ai.edge.litert:litert'
    implementation 'com.google.ai.edge.litert:litert-gpu'
    implementation 'com.google.ai.edge.litert:litert-gpu-api'
}

GPU-Beschleunigung aktivieren

Führen Sie dann LiteRT mit TfLiteDelegate auf der GPU aus. In Java können Sie angeben, GpuDelegate bis 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);
      

Quantisierte Modelle

Android GPU Delegate-Bibliotheken unterstützen standardmäßig quantisierte Modelle. Du nicht Änderungen am Code vornehmen, um quantisierte Modelle mit dem GPU-Delegaten zu verwenden. Die Im folgenden Abschnitt wird erläutert, wie Sie die quantisierte Unterstützung für Tests oder zu experimentellen Zwecken.

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 unter GPU Delegate