È 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:
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'
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());
Abilita il delegato GPU nelle opzioni dell'interprete. Imposta il valore di fabbrica del delegato su GpuDelegateIndustry tramite la chiamata a
addDelegateFactory() within
InterpreterApi.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:
- Consulta la sezione Limitazioni di questa pagina per assicurarti che il tuo caso d'uso sia supportato.
- 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.
- 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. - 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. - Aggiungi
import org.tensorflow.lite.InterpreterApi;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a qualsiasi file di origine utilizzando le classiorg.tensorflow.lite.Interpreter
oorg.tensorflow.lite.InterpreterApi
. - Se una delle chiamate a
InterpreterApi.create()
risultanti ha un solo argomento, aggiunginew InterpreterApi.Options()
all'elenco di argomenti. - Aggiungi
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
all'ultimo argomento di qualsiasi chiamata aInterpreterApi.create()
. - Sostituisci tutte le altre occorrenze della classe
org.tensorflow.lite.Interpreter
conorg.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.