TensorFlow Lite nell'API Java dei servizi Google Play

È 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à:

  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. Inizializza il delegato GPU con setEnableGpuDelegateSupport . Ad esempio, puoi inizializzare il delegato GPU per TfLiteVision con quanto segue:

    Kotlin

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())

    Giava

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());

  3. Abilita l'opzione delegato GPU con BaseOptions :

    Kotlin

        val baseOptions = BaseOptions.builder().useGpu().build()

    Giava

        BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

  4. Configura le opzioni utilizzando .setBaseOptions . Ad esempio, puoi configurare la GPU in ObjectDetector 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:

  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 delegato GPU nell'inizializzazione TFlite:

    Kotlin

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build())

    Giava

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build());

  3. 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:

  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 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.
  3. 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.
  4. 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 .
  5. Aggiungi import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a qualsiasi file sorgente utilizzando le classi org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi .
  6. Se una qualsiasi delle chiamate risultanti a InterpreterApi.create() ha un solo argomento, aggiungi new InterpreterApi.Options() all'elenco degli 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 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.