LiteRT nell'API Java di Google Play Services

È possibile accedere a LiteRT in Google Play Services anche utilizzando le API Java, in oltre all'API Native. 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 TensorFlow, fornisce un'interfaccia generica per la creazione e l'esecuzione di modelli ML. Utilizza la seguente passaggi per eseguire le inferenze con l'API Interpreter utilizzando 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 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()));
  });

Dovresti utilizzare l'implementazione sopra riportata perché evita di bloccare Android il thread dell'interfaccia utente. 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). Tu sfruttare questi processori specializzati utilizzando driver hardware chiamati delegati.

Il delegato GPU viene fornito tramite Google Play Services e viene caricato in modo dinamico, proprio come le versioni di Play Services l'API Interpreter.

Controllo della compatibilità del dispositivo in corso...

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 alternativa per i casi in cui 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. Abilita 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 il fabbrica del delegato su GpuDelega Fabbrica tramite la chiamata a 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. Consulta la sezione Limitazioni di questa pagina per assicurarti che il tuo è 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 il runtime LiteRT esistente di libreria (le voci con org.tensorflow:tensorflow-lite:*) dal file build.gradle in modo da poter ridurre le dimensioni dell'app.
4. Identifica tutte le occorrenze della creazione di oggetti new Interpreter nel tuo codice, e modificare ognuno di essi in modo da utilizzare la chiamata InterpreterApi.create(). La nuovo TfLite.initialize è asincrono, il che significa che nella maggior parte dei casi non sostituzione diretta: devi registrare un listener per quando viene effettuata la chiamata vengono completate. 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 al numero 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 mentre le versioni precedenti non sono compatibili con la versione dell'API Play Services.