LiteRT w interfejsie API usług Google Play w języku Java (i Kotlin)

Do LiteRT w Usługach Google Play można też uzyskać dostęp za pomocą interfejsów API Java, z których można korzystać w kodzie Java lub Kotlin, a także za pomocą natywnego interfejsu API. W szczególności LiteRT w usługach Google Play jest dostępny za pomocą interfejsu LiteRT Interpreter API.

Korzystanie z interfejsów API tłumacza

Interfejs LiteRT Interpreter API, udostępniany przez środowisko wykonawcze TensorFlow, zapewnia ogólny interfejs do tworzenia i uruchamiania modeli ML. Aby uruchomić wnioskowanie za pomocą interfejsu Interpreter API przy użyciu środowiska wykonawczego TensorFlow Lite w Usługach Google Play, wykonaj te czynności:

1. Dodawanie zależności projektu

Aby uzyskać dostęp do interfejsu Play Services API dla LiteRT, dodaj do kodu projektu aplikacji te zależności:

dependencies {
...
    // LiteRT dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
    // Optional: include LiteRT Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}

2. Dodawanie inicjowania LiteRT

Zainicjuj komponent LiteRT interfejsu API Usług Google Play przed użyciem interfejsów LiteRT API:

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Task<Void> initializeTask = TfLite.initialize(context);

3. Tworzenie interpretera i ustawianie opcji środowiska wykonawczego

Utwórz interpreter za pomocą funkcji InterpreterApi.create() i skonfiguruj go tak, aby korzystał z czasu działania Usług Google Play, wywołując funkcję InterpreterApi.Options.setRuntime(), jak pokazano w tym przykładowym kodzie:

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

Zalecamy używanie powyższej implementacji, ponieważ nie blokuje ona wątku interfejsu użytkownika Androida. Jeśli chcesz dokładniej zarządzać wykonywaniem wątków, możesz dodać wywołanie Tasks.await() do tworzenia interpretera:

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. Uruchamianie wnioskowania

Korzystając z utworzonego obiektu interpreter, wywołaj metodę run(), aby wygenerować wnioskowanie.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Akceleracja sprzętowa

LiteRT umożliwia przyspieszenie działania modelu za pomocą specjalistycznych procesorów sprzętowych, takich jak procesory graficzne (GPU). Możesz korzystać z tych specjalistycznych procesorów za pomocą sterowników sprzętowych zwanych delegatami.

Delegat GPU jest udostępniany w ramach usług Google Play i ładowany dynamicznie, podobnie jak wersje interfejsu Interpreter API w usługach Play.

Sprawdzanie zgodności urządzenia

Nie wszystkie urządzenia obsługują akcelerację sprzętową GPU w TFLite. Aby uniknąć błędów i potencjalnych awarii, użyj metody TfLiteGpu.isGpuDelegateAvailable, aby sprawdzić, czy urządzenie jest zgodne z delegatem GPU.

Użyj tej metody, aby sprawdzić, czy urządzenie jest zgodne z GPU, a w przypadku braku obsługi GPU użyj procesora.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Gdy masz już zmienną, np. useGpuTask, możesz jej użyć, aby określić, czy urządzenia używają delegata GPU.

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}
    

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});
    

GPU z interfejsami Interpreter API

Aby używać delegata GPU z interfejsami Interpreter API:

1. Zaktualizuj zależności projektu, aby używać delegata GPU z Usług Google Play:

   implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'
   

2. Włącz opcję delegata GPU podczas inicjowania TFlite:

   Kotlin

   TfLite.initialize(context,
     TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build())

   Java

   TfLite.initialize(context,
     TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build());

3. Włącz delegata GPU w opcjach interpretera: ustaw fabrykę delegatów na GpuDelegateFactory, wywołując addDelegateFactory() withinInterpreterApi.Options()`:

   Kotlin

   val interpreterOption = InterpreterApi.Options()
     .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
     .addDelegateFactory(GpuDelegateFactory())

   Java

   Options interpreterOption = InterpreterApi.Options()
     .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
     .addDelegateFactory(new GpuDelegateFactory());

Migracja z samodzielnej wersji LiteRT

Jeśli planujesz przenieść aplikację z samodzielnej biblioteki LiteRT do interfejsu API Usług Play, zapoznaj się z tymi dodatkowymi wskazówkami dotyczącymi aktualizowania kodu projektu aplikacji:

1. Zapoznaj się z sekcją Ograniczenia, aby sprawdzić, czy Twój przypadek użycia jest obsługiwany.
2. Przed zaktualizowaniem kodu zalecamy sprawdzenie wydajności i dokładności modeli, zwłaszcza jeśli używasz wersji LiteRT (TF Lite) starszych niż 2.1. Dzięki temu będziesz mieć punkt odniesienia do porównania z nową implementacją.
3. Jeśli cały kod został przeniesiony do interfejsu API usług Play na potrzeby LiteRT, usuń z pliku build.gradle zależności biblioteki środowiska wykonawczego LiteRT (wpisy z org.tensorflow:tensorflow-lite:*), aby zmniejszyć rozmiar aplikacji.
4. Znajdź w kodzie wszystkie wystąpienia tworzenia obiektu new Interpreter i zmodyfikuj je tak, aby korzystały z wywołania InterpreterApi.create(). Nowa funkcja TfLite.initialize jest asynchroniczna, co oznacza, że w większości przypadków nie jest zamiennikiem typu „plug and play”: musisz zarejestrować odbiornik, który będzie powiadamiał o zakończeniu wywołania. Skorzystaj z fragmentu kodu z Kroku 3.
5. Dodaj elementy import org.tensorflow.lite.InterpreterApi; i import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; do dowolnych plików źródłowych, używając klas org.tensorflow.lite.Interpreter lub org.tensorflow.lite.InterpreterApi.
6. Jeśli którekolwiek z wywołań funkcji InterpreterApi.create() ma tylko jeden argument, dodaj do listy argumentów new InterpreterApi.Options().
7. Dołącz .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) do ostatniego argumentu wszystkich wywołań funkcji InterpreterApi.create().
8. Zastąp wszystkie pozostałe wystąpienia klasy org.tensorflow.lite.Interpreter klasą org.tensorflow.lite.InterpreterApi.

Jeśli chcesz używać samodzielnej biblioteki LiteRT i interfejsu API Usług Play równolegle, musisz używać biblioteki LiteRT (TF Lite) w wersji 2.9 lub nowszej. LiteRT (TF Lite) w wersji 2.8 i starszych nie jest zgodny z wersją interfejsu API Usług Play.