LiteRT nell'API Java di Google Play Services

È possibile accedere a LiteRT in Google Play Services anche utilizzando le API Java, oltre all'API nativa. In particolare, LiteRT in Google Play sono disponibili tramite LiteRT Interpreter tramite Google Cloud.

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 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 a Google Play API services per 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. Aggiungi l'inizializzazione di LiteRT

Inizializzare 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 usando InterpreterApi.create() e configuralo per usare il servizio Runtime di Google Play Services, chiamando il numero 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, può 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

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 consente di accelerare le prestazioni del modello utilizzando processori hardware specializzati, come le GPU (Graphics Processing Unit). Puoi usufruire di 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 per mitigare errori e potenziali arresti anomali, utilizza TfLiteGpu.isGpuDelegateAvailable metodo 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 opzione di riserva quando la GPU non è supportata.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Quando hai una variabile come useGpuTask, puoi utilizzarla per determinare se che 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 da Play Services:

   implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.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. 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 autonomo

Se prevedi di eseguire la migrazione della tua app da LiteRT standalone Per l'aggiornamento dell'API Play Services, leggi le seguenti indicazioni aggiuntive codice progetto app:

1. Esamina la sezione Limitazioni di questa pagina per assicurarti che il tuo caso d'uso sia supportato.
2. Prima di aggiornare il codice, esegui controlli delle prestazioni e dell'accuratezza del tuo di grandi dimensioni, in particolare se utilizzi versioni di LiteRT precedenti rispetto alla versione 2.1, quindi avete una 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 esistenti della libreria di runtime LiteRT (le voci con org.tensorflow:tensorflow-lite:*) dal file build.gradle per ridurre le dimensioni dell'app.
4. Identifica tutte le occorrenze della creazione di oggetti new Interpreter nel codice e modificale in modo che utilizzino la chiamata InterpreterApi.create(). Il nuovo TfLite.initialize è asincrono, il che significa che nella maggior parte dei casi non è una sostituzione plug-and-play: devi registrare un ascoltatore per il completamento della chiamata. Fai riferimento allo snippet di codice nel Passaggio 3.
5. Aggiungi import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a qualsiasi origine utilizzando lo strumento org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi corsi.
6. Se una delle chiamate risultanti a InterpreterApi.create() ha solo un singolo 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 usare LiteRT standalone e l'API Play Services uno accanto all'altro, devi utilizzare LiteRT 2.9 (o versioni successive). LiteRT 2.8 e le versioni precedenti non sono compatibili con la versione dell'API Play Services.