Delegat do akceleracji GPU w przypadku interfejsu Interpreter API

Korzystanie z procesorów graficznych (GPU) do uruchamiania modeli systemów uczących się może znacznie poprawić wydajność i wygodę użytkowników Aplikacje obsługujące systemy uczące się. Na urządzeniach z Androidem możesz włączyć degate i jeden z tych interfejsów API:

  • Interpreter API – ten przewodnik
  • Natywny (C/C++) API – przewodnik

Na tej stronie dowiesz się, jak włączyć akcelerację GPU w modelach LiteRT w aplikacje na Androida używające interfejsu Interpreter API, Więcej informacji o korzystaniu z GPU o przekazywanie dostępu do platformy LiteRT, w tym sprawdzonych metod i zaawansowanych technik, zobacz stronę Przedstawiciele GPU.

Używaj GPU w połączeniu LiteRT z Usługami Google Play

Tłumacz literatury LiteRT API udostępnia zestaw interfejsów API ogólnego przeznaczenia do tworzenia aplikacji do uczenia maszynowego. Ta sekcja zawiera opis sposobu korzystania z przedstawiciela akceleratora GPU z tymi interfejsami API za pomocą LiteRT z Usługami Google Play.

Zalecamy korzystanie z platformy LiteRT z Usługami Google Play. jak korzystać z LiteRT na Androidzie. Jeśli aplikacja jest kierowana na urządzenia bez Google Play, zapoznaj się z artykułem Interfejs GPU z interfejsem Interpreter API LiteRT.

Dodaj zależności projektu (z katalogiem wersji .toml)

  1. Zaktualizuj plik libs.versions.toml projektu
[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. Dodaj zależności projektu w źródle build.gradle.kts aplikacji
dependencies {
  ...
  implementation(libraries.tflite.gpu)
  implementation(libraries.tflite.gpu.api)
  ...
}

Dodaj zależności projektu

Aby włączyć dostęp do przedstawicieli GPU, dodaj com.google.android.gms:play-services-tflite-gpu na koncie build.gradle Twojej aplikacji plik:

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

Włącz akcelerację GPU

Następnie zainicjuj LiteRT z Usługami Google Play z obsługą GPU:

Kotlin

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

Java

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

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

Na koniec możesz zainicjować tłumacza, który przekazuje polecenie GpuDelegateFactory do 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);

Przedstawiciela GPU można też używać z powiązaniem modelu ML w Android Studio. Dla: więcej informacji znajdziesz w artykule Generowanie interfejsów modelu za pomocą metadanych.

Używaj GPU z samodzielną wersją LiteRT

Jeśli Twoja aplikacja jest kierowana na urządzenia bez aplikacji Google Play, można powiązać z aplikacją delegację GPU i używać go w komponencie wersji oddzielnej LiteRT.

Dodaj zależności projektu

Aby włączyć dostęp do przedstawicieli GPU, dodaj com.google.ai.edge.litert:litert-gpu-delegate-plugin na Plik build.gradle:

dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite'
    implementation 'com.google.ai.edge.litert:litert-gpu-delegate-plugin'
}

Włącz akcelerację GPU

Następnie uruchom LiteRT z użyciem GPU, używając TfLiteDelegate. W Javie możesz określić GpuDelegate do 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);

Modele kwantowe

Biblioteki delegowanych GPU w Androidzie obsługują domyślnie modele kwantowe. Ty nie nie muszą wprowadzać żadnych zmian w kodzie, aby używać kwantyzowanych modeli z delegacją GPU. poniżej dowiesz się, jak wyłączyć kwantyzowaną obsługę testów lub do celów eksperymentalnych.

Wyłącz obsługę modeli kwantowych

Ten kod pokazuje, jak wyłączyć obsługę modeli kwantyzowanych.

Java

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

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

Więcej informacji o uruchamianiu modeli kwantowych z akceleracją GPU znajdziesz w artykule Omówienie przekazywania dostępu do GPU.