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 API tłumaczenia rozmowy

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

1. Dodaj 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

Zainicjuj komponent LiteRT interfejsu Google Play Services API przed użyciem interfejsów API LiteRT:

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

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

3. Tworzenie tłumaczenia rozmowy i ustawianie opcji środowiska wykonawczego

Utwórz interpreter za pomocą dodatku InterpreterApi.create() i skonfiguruj go do używania Środowisko wykonawcze Usług Google Play, wywołując InterpreterApi.Options.setRuntime(), jak 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 tej implementacji, ponieważ pozwala ona uniknąć blokowania Androida wątku interfejsu. 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

Za pomocą utworzonego obiektu interpreter wywołaj metodę run(), aby wygenerować wnioskowania.

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). Ty mogą wykorzystać te specjalistyczne procesory za pomocą sterowników sprzętowych nazywanych delegatów.

Przekazywanie dostępu do GPU jest realizowane przez Usługi Google Play i jest dynamicznie ładowany, tak jak wersje Usług Google Play Interpreter API.

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ć delegata GPU w interfejsach API tłumaczenia rozmowy:

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

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

2. Włącz opcję przekazywania dostępu do GPU podczas inicjowania pliku 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 samodzielnej platformy 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. Zapoznaj się z sekcją Ograniczenia na tej stronie, aby upewnić się, dla danego przypadku użycia.
2. Przed aktualizacją kodu sprawdź skuteczność i dokładność modeli, zwłaszcza jeśli korzystasz z wcześniejszych wersji LiteRT. niż w wersji 2.1, więc masz punkt odniesienia do porównania implementacji.
3. Jeśli cały kod został przeniesiony, aby korzystać z interfejsu Play Services API LiteRT, usuń istniejące środowisko wykonawcze LiteRT zależności biblioteki (wpisy 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(). Polecenie nowego TfLite.initialize jest asynchroniczne, co oznacza, że w większości przypadków wymiana bezdotykowa: musisz zarejestrować detektor, gdy połączenie . 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 wywołań InterpreterApi.create() ma tylko pojedynczy argument, dołącz new InterpreterApi.Options() do listy argumentów.
7. Dołącz .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) do ostatniego argumentu argumentu wszystkich połączeń z numerem InterpreterApi.create().
8. Zastąp wszystkie pozostałe wystąpienia klasy org.tensorflow.lite.Interpreter dzięki org.tensorflow.lite.InterpreterApi.

Jeśli chcesz używać samodzielnej platformy LiteRT i interfejsu Play Services API obok siebie, musisz używać LiteRT 2.9 (lub nowszej wersji). LiteRT 2.8 i wcześniejszych wersji nie są zgodne z wersją interfejsu Play Services API.