LiteRT w interfejsie Java API Usług Google Play

Do platformy LiteRT w Usługach Google Play można też uzyskać dostęp za pomocą interfejsów Java API w z natywnym interfejsem API. W szczególności dotyczy to LiteRT w Google Play są dostępne za pomocą aplikacji LiteRT Interpreter API.

Korzystanie z interfejsów Interpreter API

Interfejs API LiteRT Interpreter udostępniany przez środowisko wykonawcze TensorFlow zapewnia interfejs ogólnego przeznaczenia do tworzenia i uruchamiania modeli systemów uczących się. Użyj te kroki, aby uruchomić wnioskowania za pomocą interfejsu Interpreter API za pomocą TensorFlow Lite w środowisku wykonawczym Usług Google Play.

1. Dodawanie zależności projektu

Aby uzyskać dostęp do Google Play, dodaj te zależności do kodu projektu aplikacji API usług dla LiteRT:

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

2. Dodaj inicjowanie LiteRT.

Przed użyciem interfejsów API LiteRT zainicjuj komponent LiteRT interfejsu API usług Google Play:

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

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

3. Tworzenie tłumacza i ustawianie opcji środowiska wykonawczego

Utwórz interpretera za pomocą funkcji InterpreterApi.create() i skonfiguruj go do używania środowiska wykonawczego 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()));
  });

Użyj implementacji powyżej, ponieważ zapobiega ona blokowaniu wątku interfejsu użytkownika Androida. Jeśli chcesz lepiej zarządzać wykonywaniem wątków, może dodać wywołanie Tasks.await() do tworzenia tłumaczenia rozmowy:

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

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

4. Uruchom 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 pozwala przyspieszyć wydajność modelu przy użyciu specjalistyczne procesory sprzętowe, takie jak procesory graficzne (GPU). Możesz korzystać z tych wyspecjalizowanych procesorów za pomocą sterowników sprzętowych zwanych podmiotami delegowanymi.

GPU delegate jest udostępniany przez usługi Google Play i ładowany dynamicznie, podobnie jak wersje interfejsu Interpreter API w Usługach Google Play.

Sprawdzanie zgodności urządzeń

Nie wszystkie urządzenia obsługują akcelerację sprzętową GPU z użyciem TFLite. Aby i eliminować ewentualne błędy, skorzystaj ze Metoda TfLiteGpu.isGpuDelegateAvailable, która pozwala sprawdzić, czy urządzenie z delegatem GPU.

Użyj tej metody, aby sprawdzić, czy urządzenie jest zgodne z GPU, i używać procesora w sytuacji, gdy GPU nie jest obsługiwane.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Gdy masz już zmienną taką jak useGpuTask, możesz jej używać do określenia, 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 API tłumaczenia rozmowy

Aby użyć delegowania do GPU w ramach interfejsów Interpreter API:

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

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

2. Włącz opcję delegowania 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 przekazywanie dostępu do GPU w opcjach tłumaczenia rozmowy: ustaw fabrykę przekazywania na GpuDelegateFactory przez wywołanie 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 samodzielnego LiteRT

Jeśli planujesz migrację swojej aplikacji z samodzielnej platformy LiteRT do Play Services API; zapoznaj się z tymi dodatkowymi wskazówkami dotyczącymi aktualizacji kod projektu aplikacji:

1. Przejrzyj sekcję Ograniczenia na tej stronie, aby sprawdzić, czy Twój przypadek użycia jest obsługiwany.
2. Zanim zaktualizujesz kod, sprawdź wydajność i dokładność swoich modeli, zwłaszcza jeśli używasz wersji LiteRT 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 Google Play w celu użycia LiteRT, musisz usunąć istniejące zależności biblioteki runtime LiteRT (elementy z org.tensorflow:tensorflow-lite:*) z pliku build.gradle, aby zmniejszyć rozmiar aplikacji.
4. Zidentyfikuj wszystkie wystąpienia w kodzie tworzenia obiektu new Interpreter, i zmodyfikować każdy z nich tak, aby używał wywołania InterpreterApi.create(). Nowa metoda TfLite.initialize jest asynchroniczna, co oznacza, że w większości przypadków nie jest to bezpośrednia wymiana: musisz zarejestrować odbiornik na czas zakończenia wywołania. Skorzystaj z fragmentu kodu w kroku 3.
5. Dodaj import org.tensorflow.lite.InterpreterApi; i import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; do dowolnego źródła za pomocą tagów org.tensorflow.lite.Interpreter lub org.tensorflow.lite.InterpreterApi zajęć.
6. Jeśli któreś z wynikających z tego wywołań funkcji InterpreterApi.create() ma tylko 1 argument, dodaj do listy argumentów element new InterpreterApi.Options().
7. Dodaj .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) do ostatniego argumentu dowolnego wywołania funkcji InterpreterApi.create().
8. Zastąp wszystkie inne wystąpienia klasy org.tensorflow.lite.Interpreter wartością org.tensorflow.lite.InterpreterApi.

Jeśli chcesz używać samodzielnego LiteRT i interfejsu API usług Google Play jednocześnie, musisz używać LiteRT w wersji 2.9 (lub nowszej). LiteRT w wersji 2.8 i starszych nie jest zgodny z wersją interfejsu API Usług Google Play.