È 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:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Java
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:
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 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:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Java
@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)
Java
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.
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 Interpreter
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 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());
Attiva il delegato GPU nelle opzioni dell'interprete: imposta il fabbrica del delegato su GpuDelega Fabbrica 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 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:
- Consulta la sezione Limitazioni di questa pagina per assicurarti che il tuo è supportato.
- 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.
- 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. - 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. - Aggiungi
import org.tensorflow.lite.InterpreterApi;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a qualsiasi origine utilizzando lo strumentoorg.tensorflow.lite.Interpreter
oorg.tensorflow.lite.InterpreterApi
corsi. - Se una delle chiamate risultanti a
InterpreterApi.create()
ha solo un singolo argomento, aggiunginew InterpreterApi.Options()
all'elenco di argomenti. - Aggiungi
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
all'ultimo argomento di qualsiasi chiamata al numeroInterpreterApi.create()
. - Sostituisci tutte le altre occorrenze della classe
org.tensorflow.lite.Interpreter
conorg.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.