È possibile accedere a TensorFlow Lite nei servizi Google Play anche utilizzando le API Java, oltre all'API nativa. In particolare, TensorFlow Lite nei servizi Google Play è disponibile tramite TensorFlow Lite Task API e TensorFlow Lite Interpreter API . La libreria attività fornisce interfacce modello ottimizzate e pronte all'uso per attività comuni di machine learning utilizzando dati visivi, audio e di testo. L'API TensorFlow Lite Interpreter, fornita dal runtime TensorFlow, fornisce un'interfaccia più generica per la creazione e l'esecuzione di modelli ML.
Le sezioni seguenti forniscono istruzioni su come utilizzare le API Interprete e Libreria attività con TensorFlow Lite nei servizi Google Play. Sebbene sia possibile che un'app utilizzi sia le API dell'interprete che le API della libreria attività, la maggior parte delle app dovrebbe utilizzare solo un set di API.
Utilizzo delle API della libreria attività
L'API TensorFlow Lite Task racchiude l'API Interpreter e fornisce un'interfaccia di programmazione di alto livello per attività comuni di machine learning che utilizzano dati visivi, audio e di testo. Dovresti utilizzare l'API Task se la tua applicazione richiede una delle attività supportate .
1. Aggiungi dipendenze del progetto
La dipendenza del progetto dipende dal caso d'uso del machine learning. Le API delle attività contengono le seguenti librerie:
- Libreria di visione:
org.tensorflow:tensorflow-lite-task-vision-play-services
- Libreria audio:
org.tensorflow:tensorflow-lite-task-audio-play-services
- Libreria di testo:
org.tensorflow:tensorflow-lite-task-text-play-services
Aggiungi una delle dipendenze al codice del progetto della tua app per accedere all'API Play Services per TensorFlow Lite. Ad esempio, utilizzare quanto segue per implementare un'attività di visione:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}
2. Aggiungi l'inizializzazione di TensorFlow Lite
Inizializza il componente TensorFlow Lite dell'API dei servizi Google Play prima di utilizzare le API TensorFlow Lite. L'esempio seguente inizializza la libreria di visione:
Kotlin
init { TfLiteVision.initialize(context) }
3. Esegui inferenze
Dopo aver inizializzato il componente TensorFlow Lite, chiama il metodo detect()
per generare inferenze. Il codice esatto all'interno del metodo detect()
varia a seconda della libreria e del caso d'uso. Quanto segue è per un semplice caso d'uso di rilevamento di oggetti con la libreria TfLiteVision
:
Kotlin
fun detect(...) { if (!TfLiteVision.isInitialized()) { Log.e(TAG, "detect: TfLiteVision is not initialized yet") return } if (objectDetector == null) { setupObjectDetector() } ... }
A seconda del formato dei dati, potrebbe anche essere necessario preelaborare e convertire i dati all'interno del metodo detect()
prima di generare inferenze. Ad esempio, i dati immagine per un rilevatore di oggetti richiedono quanto segue:
val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)
Utilizzo delle API dell'interprete
Le API dell'interprete offrono maggiore controllo e flessibilità rispetto alle API della libreria di attività. Dovresti utilizzare le API Interpreter se la tua attività di machine learning non è supportata dalla libreria Task o se hai bisogno di un'interfaccia più generica per la creazione e l'esecuzione di modelli ML.
1. Aggiungi dipendenze del progetto
Aggiungi le seguenti dipendenze al codice del progetto della tua 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 l'inizializzazione di TensorFlow Lite
Inizializza il componente TensorFlow Lite dell'API dei servizi Google Play prima di utilizzare le API TensorFlow Lite:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Giava
Task<Void> initializeTask = TfLite.initialize(context);
3. Creare un interprete e impostare l'opzione di runtime
Crea un interprete utilizzando InterpreterApi.create()
e configuralo per utilizzare il runtime dei servizi Google Play, chiamando InterpreterApi.Options.setRuntime()
, come mostrato nel seguente codice di esempio:
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) }
Giava
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 perché evita di bloccare il thread dell'interfaccia utente Android. Se hai bisogno di gestire l'esecuzione del thread più da vicino, puoi aggiungere una chiamata Tasks.await()
alla creazione dell'interprete:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Giava
@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.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Giava
interpreter.run(inputBuffer, outputBuffer);
Accelerazione hardware
TensorFlow Lite ti consente di accelerare le prestazioni del tuo modello utilizzando processori hardware specializzati, come unità di elaborazione grafica (GPU). Puoi sfruttare questi processori specializzati utilizzando driver hardware chiamati delegati . Puoi utilizzare i seguenti delegati di accelerazione hardware con TensorFlow Lite nei servizi Google Play:
Delegato GPU (consigliato) : questo delegato viene fornito tramite Google Play Services e viene caricato dinamicamente, proprio come le versioni Play Services dell'API Task e dell'API Interpreter.
Delegato NNAPI : questo delegato è disponibile come dipendenza della libreria inclusa nel progetto di sviluppo Android ed è integrato nella tua app.
Per ulteriori informazioni sull'accelerazione hardware con TensorFlow Lite, consulta la pagina dei delegati di TensorFlow Lite .
Verifica della compatibilità del dispositivo
Non tutti i dispositivi supportano l'accelerazione hardware GPU con TFLite. Per mitigare errori e potenziali arresti anomali, utilizzare il metodo TfLiteGpu.isGpuDelegateAvailable
per verificare se un dispositivo è compatibile con il delegato GPU.
Utilizza questo metodo per verificare se un dispositivo è compatibile con la GPU e utilizza la CPU o il delegato NNAPI come fallback per quando la GPU non è supportata.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Una volta che hai una variabile come useGpuTask
, puoi usarla per determinare se i dispositivi utilizzano il delegato GPU. Gli esempi seguenti mostrano come è possibile eseguire questa operazione sia con la libreria delle attività che con le API dell'interprete.
Con l'API Task
Kotlin
lateinit val optionsTask = useGpuTask.continueWith { task -> val baseOptionsBuilder = BaseOptions.builder() if (task.result) { baseOptionsBuilder.useGpu() } ObjectDetectorOptions.builder() .setBaseOptions(baseOptionsBuilder.build()) .setMaxResults(1) .build() }
Giava
Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task -> BaseOptions baseOptionsBuilder = BaseOptions.builder(); if (task.getResult()) { baseOptionsBuilder.useGpu(); } return ObjectDetectorOptions.builder() .setBaseOptions(baseOptionsBuilder.build()) .setMaxResults(1) .build() });
Con l'Api Interprete
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) }
Giava
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 della libreria attività
Per utilizzare il delegato GPU con le API delle attività:
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'
Inizializza il delegato GPU con
setEnableGpuDelegateSupport
. Ad esempio, puoi inizializzare il delegato GPU perTfLiteVision
con quanto segue:Kotlin
TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())
Giava
TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());
Abilita l'opzione delegato GPU con
BaseOptions
:Kotlin
val baseOptions = BaseOptions.builder().useGpu().build()
Giava
BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
Configura le opzioni utilizzando
.setBaseOptions
. Ad esempio, puoi configurare la GPU inObjectDetector
con quanto segue:Kotlin
val options = ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build()
Giava
ObjectDetectorOptions options = ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build();
GPU con API di interprete
Per utilizzare il delegato GPU con le API Interpreter:
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'
Abilita l'opzione delegato GPU nell'inizializzazione TFlite:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Giava
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
Abilita il delegato GPU nelle opzioni dell'interprete: imposta la factory del delegato su GpuDelegateFactory chiamando
addDelegateFactory() within
InterpreterApi.Options()`:Kotlin
val interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory())
Giava
Options interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory());
Migrazione da TensorFlow Lite autonomo
Se hai intenzione 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 delle prestazioni e dell'accuratezza dei 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, dovresti rimuovere le dipendenze esistenti della libreria runtime di TensorFlow Lite (voci con
org.tensorflow: tensorflow-lite :*
) dal file build.gradle in modo da poter puoi ridurre le dimensioni dell'app. - Identifica tutte le occorrenze della creazione di
new Interpreter
nel tuo codice e modifica ciascuna di esse in modo che utilizzi la chiamata InterpreterApi.create(). Il nuovo TfLite.initialize è asincrono, il che significa che nella maggior parte dei casi non è un sostituto immediato: è necessario registrare un ascoltatore per il completamento della chiamata. Fare riferimento allo snippet di codice nel codice del passaggio 3 . - Aggiungi
import org.tensorflow.lite.InterpreterApi;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a qualsiasi file sorgente utilizzando le classiorg.tensorflow.lite.Interpreter
oorg.tensorflow.lite.InterpreterApi
. - Se una qualsiasi delle chiamate risultanti a
InterpreterApi.create()
ha un solo argomento, aggiunginew InterpreterApi.Options()
all'elenco degli 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 desideri utilizzare TensorFlow Lite autonomo e l'API Play Services fianco a fianco, devi utilizzare TensorFlow Lite 2.9 (o versione successiva). TensorFlow Lite 2.8 e le versioni precedenti non sono compatibili con la versione dell'API Play Services.