TensorFlow Lite nell'API Java di Google Play Services

È possibile accedere a TensorFlow Lite in Google Play Services anche utilizzando le API Java, oltre all'API Native. In particolare, TensorFlow Lite in Google Play Services è disponibile tramite l'API TensorFlow Lite Interpreter.

Utilizzo delle API Interpreter

L'API TensorFlow Lite Interpreter, fornita dal runtime TensorFlow, offre un'interfaccia generica per la creazione e l'esecuzione di modelli ML. Segui i passaggi seguenti 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 TensorFlow Lite:

dependencies {
...
    // Tensorflow Lite dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    // Optional: include Tensorflow Lite Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}

2. Aggiungi inizializzazione di TensorFlow Lite

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

Kotlin

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

Java

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

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

Crea un interprete utilizzando InterpreterApi.create() e configuralo per l'utilizzo del runtime di Google Play Services chiamando InterpreterApi.Options.setRuntime(), come mostrato nel codice di esempio che segue:

Kotlin

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

Java

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 usare 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() per la creazione dell'interprete:

Kotlin

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

Java

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

4. Eseguire inferenze

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

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

Accelerazione hardware

TensorFlow Lite consente di accelerare le prestazioni del 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 in modo dinamico, proprio come le versioni Play Services dell'API Interpreter.

Verifica della compatibilità del dispositivo in corso...

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

Utilizza questo metodo per confermare se un dispositivo è compatibile con la GPU e utilizza la CPU come riserva per i casi in cui 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.

Kotlin

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

Java

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 interprete

Per utilizzare il delegato GPU con le API Interprete:

  1. Aggiorna le dipendenze del progetto in modo da utilizzare il delegato GPU di Play Services:

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

  2. Abilita l'opzione 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. Abilita il delegato GPU nelle opzioni dell'interprete. Imposta il valore di fabbrica del delegato su GpuDelegateIndustry 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 TensorFlow Lite autonomo

Se prevedi di eseguire la migrazione della tua app da TensorFlow Lite 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, esegui controlli di prestazioni e accuratezza per i tuoi modelli, in particolare se utilizzi versioni di TensorFlow 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 TensorFlow Lite, devi rimuovere le dipendenze della libreria di runtime di TensorFlow Lite (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 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 costituisce una sostituzione diretta: devi registrare un listener per il completamento della chiamata. Consulta lo snippet di codice nel 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 a InterpreterApi.create() risultanti 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 TensorFlow Lite autonomo e l'API Play Services affiancati, devi usare TensorFlow Lite 2.9 (o versioni successive). TensorFlow Lite 2.8 e le versioni precedenti non sono compatibili con la versione dell'API Play Services.