LiteRT nell'API Java (e Kotlin) di Google Play Services

È possibile accedere a LiteRT nei servizi Google Play anche utilizzando le API Java, che possono essere utilizzate dal codice Java o Kotlin, oltre all'API nativa. In particolare, LiteRT nei servizi Google Play è disponibile tramite l'API LiteRT Interpreter.

Utilizzo delle API Interpreter

L'API LiteRT Interpreter, fornita dal runtime TensorFlow, offre un'interfaccia generica per la creazione e l'esecuzione di modelli ML. Segui questi passaggi per eseguire inferenze con l'API Interpreter utilizzando TensorFlow Lite nel runtime dei servizi Google Play.

1. Aggiungere le dipendenze del progetto

Aggiungi le seguenti dipendenze al codice del progetto dell'app per accedere all'API Play Services per LiteRT:

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. Aggiungi l'inizializzazione di LiteRT

Inizializza il componente LiteRT dell'API Google Play Services prima di utilizzare le API LiteRT:

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

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

3. Crea un interprete e imposta l'opzione di runtime

Crea un interprete utilizzando InterpreterApi.create() e configuralo per utilizzare il runtime di Google Play Services chiamando InterpreterApi.Options.setRuntime(), come mostrato nel seguente esempio di codice:

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()));
  });

Devi utilizzare l'implementazione riportata sopra perché evita di bloccare il thread dell'interfaccia utente di Android. Se devi gestire l'esecuzione dei thread in modo più preciso, puoi aggiungere una chiamata Tasks.await() alla creazione dell'interprete:

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

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

4. Eseguire inferenze

Utilizzando l'oggetto interpreter che hai creato, chiama il metodo run() per generare un'inferenza.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Accelerazione hardware

LiteRT ti consente di accelerare le prestazioni del modello utilizzando processori hardware specializzati, come le unità di elaborazione grafica (GPU). Puoi sfruttare questi processori specializzati utilizzando driver hardware chiamati delegati.

Il delegato GPU viene fornito tramite Google Play Services e viene caricato dinamicamente, proprio come le versioni di Play Services dell'API Interpreter.

Verifica della compatibilità dei dispositivi

Non tutti i dispositivi supportano l'accelerazione hardware della GPU con TFLite. Per ridurre gli errori e i potenziali arresti anomali, utilizza il metodo TfLiteGpu.isGpuDelegateAvailable per verificare se un dispositivo è compatibile con il delegato GPU.

Utilizza questo metodo per verificare se un dispositivo è compatibile con la GPU e utilizza la CPU come fallback quando la GPU non è supportata.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Una volta che hai una variabile come useGpuTask, puoi utilizzarla per determinare se i dispositivi utilizzano il delegato 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 con API Interpreter

Per utilizzare il delegato GPU con le API Interpreter:

1. Aggiorna le dipendenze del progetto per utilizzare il delegato GPU di Play Services:

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

2. Attiva l'opzione di delega GPU nell'inizializzazione di TFlite:

   Kotlin

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

   Java

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

3. Attiva il delegato GPU nelle opzioni dell'interprete: imposta la fabbrica del delegato su GpuDelegateFactory chiamando 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());

Migrazione da LiteRT standalone

Se prevedi di eseguire la migrazione della tua app da LiteRT standalone all'API Play Services, consulta le seguenti indicazioni aggiuntive per aggiornare il codice del progetto dell'app:

1. Esamina la sezione Limitazioni per assicurarti che il tuo caso d'uso sia supportato.
2. Prima di aggiornare il codice, ti consigliamo di eseguire controlli di rendimento e precisione per i tuoi modelli, in particolare se utilizzi versioni di LiteRT (TF Lite) precedenti alla versione 2.1, in modo da avere una base di riferimento da confrontare con la nuova implementazione.
3. Se hai eseguito la migrazione di tutto il codice per utilizzare l'API Play Services per LiteRT, devi rimuovere le dipendenze esistenti della libreria di runtime LiteRT (voci con org.tensorflow:tensorflow-lite:*) dal file build.gradle in modo da ridurre le dimensioni dell'app.
4. Identifica tutte le occorrenze della creazione di oggetti new Interpreter nel tuo codice e modifica ognuna in modo che utilizzi la chiamata InterpreterApi.create(). Il nuovo TfLite.initialize è asincrono, il che significa che nella maggior parte dei casi non è un sostituto immediato: devi registrare un listener per quando la chiamata viene completata. Fai riferimento allo snippet di codice nel codice del passaggio 3.
5. Aggiungi import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a qualsiasi file di origine utilizzando le classi org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi.
6. Se una delle chiamate risultanti a InterpreterApi.create() ha un solo argomento, aggiungi new InterpreterApi.Options() all'elenco degli argomenti.
7. Aggiungi .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) all'ultimo argomento di qualsiasi chiamata a InterpreterApi.create().
8. Sostituisci tutte le altre occorrenze della classe org.tensorflow.lite.Interpreter con org.tensorflow.lite.InterpreterApi.

Se vuoi utilizzare LiteRT autonomo e l'API Play Services affiancati, devi utilizzare LiteRT (TF Lite) versione 2.9 o successive. LiteRT (TF Lite) versione 2.8 e precedenti non sono compatibili con la versione dell'API Play Services.