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

È possibile accedere a LiteRT in 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 di TensorFlow, fornisce un'interfaccia generica per creare ed eseguire modelli ML. Segui questi passaggi per eseguire le inferenze con l'API Interpreter utilizzando TensorFlow Lite nel runtime di Google Play Services.

1. Aggiungi 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 in modo da utilizzare il runtime di Google Play Services chiamando InterpreterApi.Options.setRuntime(), come mostrato nel seguente codice di esempio:

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

Ti consigliamo di utilizzare l'implementazione riportata sopra perché evita di bloccare il thread dell'interfaccia utente di Android. Se hai bisogno di gestire più da vicino l'esecuzione dei thread, 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. Esegui inferenze

Utilizza l'oggetto interpreter che hai creato per chiamare il metodo run() e generare un'inferenza.

interpreter.run(inputBuffer, outputBuffer)

interpreter.run(inputBuffer, outputBuffer);

Accelerazione hardware

LiteRT consente di accelerare le prestazioni del tuo modello utilizzando processori hardware specializzati, come le GPU (Graphics Processing Unit). 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 Interprete.

Verificare la compatibilità del dispositivo

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

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Una volta creata 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 di interprete

Per utilizzare il delegato GPU con le API Interpreter:

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

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

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

   Kotlin

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

   Java

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

3. Abilita il delegato GPU nelle opzioni dell'interprete: imposta il valore di fabbrica del delegato su GpuDelegate Fab 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 autonomo

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

1. Consulta la sezione Limitazioni di questa pagina per assicurarti che il tuo caso d'uso sia supportato.
2. Prima di aggiornare il codice, ti consigliamo di eseguire controlli di rendimento e accuratezza per i tuoi modelli, in particolare se utilizzi versioni di LiteRT (TF Lite) precedenti alla 2.1, in modo da avere una linea di base 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 della libreria di runtime esistenti (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 codice e modificale ognuna in modo che utilizzi la chiamata InterpreterApi.create(). Il nuovo TfLite.initialize è asincrono, il che significa che nella maggior parte dei casi non si tratta di una sostituzione diretta: devi registrare un listener per il completamento della chiamata. 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 i tipi 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 di 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 autonome e l'API Play Services affiancate, devi utilizzare LiteRT (TF Lite) versione 2.9 o successive. LiteRT (TF Lite) versione 2.8 e versioni precedenti non sono compatibili con la versione dell'API Play Services.