Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Avvio rapido di Android

Per iniziare con TensorFlow Lite su Android, ti consigliamo di esplorare il seguente esempio.

Esempio di classificazione delle immagini Android

Leggi la classificazione delle immagini Android di TensorFlow Lite per una spiegazione del codice sorgente.

Questa app di esempio utilizza la classificazione delle immagini per classificare continuamente ciò che vede dalla fotocamera posteriore del dispositivo. L'applicazione può essere eseguita sul dispositivo o sull'emulatore.

L'inferenza viene eseguita utilizzando l'API Java di TensorFlow Lite e la libreria di supporto Android di TensorFlow Lite . L'app demo classifica i frame in tempo reale, visualizzando le classificazioni più probabili. Consente all'utente di scegliere tra un modello in virgola mobile o quantizzato , selezionare il conteggio dei thread e decidere se eseguire su CPU, GPU o tramite NNAPI .

Crea in Android Studio

Per creare l'esempio in Android Studio, segui le istruzioni in README.md .

Crea la tua app Android

Per iniziare rapidamente a scrivere il tuo codice Android, ti consigliamo di utilizzare il nostro esempio di classificazione delle immagini Android come punto di partenza.

Le sezioni seguenti contengono alcune informazioni utili per lavorare con TensorFlow Lite su Android.

Usa la libreria di supporto Android di TensorFlow Lite

La libreria di supporto Android di TensorFlow Lite semplifica l'integrazione dei modelli nella tua applicazione. Fornisce API di alto livello che aiutano a trasformare i dati di input non elaborati nella forma richiesta dal modello e interpretano l'output del modello, riducendo la quantità di codice standard richiesto.

Supporta formati di dati comuni per input e output, comprese immagini e array. Fornisce inoltre unità di pre e post-elaborazione che eseguono attività come il ridimensionamento e il ritaglio delle immagini.

Per iniziare, segui le istruzioni nella libreria di supporto Android di TensorFlow Lite README.md .

Usa TensorFlow Lite AAR di JCenter

Per utilizzare TensorFlow Lite nella tua app Android, ti consigliamo di utilizzare TensorFlow Lite AAR ospitato in JCenter .

Puoi specificarlo nelle tue dipendenze build.gradle come segue:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly'
}

Questa AAR include i file binari per tutte le ABI Android . Puoi ridurre la dimensione del file binario della tua applicazione includendo solo gli ABI che devi supportare.

Consigliamo alla maggior parte degli sviluppatori di omettere gli arm32 x86 , x86_64 e arm32. Ciò può essere ottenuto con la seguente configurazione Gradle, che include specificamente solo armeabi-v7a e arm64-v8a , che dovrebbero coprire la maggior parte dei dispositivi Android moderni.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Per ulteriori informazioni su abiFilters , vedere NdkOptions nella documentazione di Android Gradle.

Crea TensorFlow Lite in locale

In alcuni casi, potresti voler utilizzare una build locale di TensorFlow Lite. Ad esempio, potresti creare un file binario personalizzato che include operazioni selezionate da TensorFlow , oppure potresti voler apportare modifiche locali a TensorFlow Lite.

Configura l'ambiente di compilazione utilizzando Docker

  • Scarica il file Docker. Scaricando il file Docker, accetti che i seguenti termini di servizio ne regolino l'utilizzo:

Facendo clic per accettare, accetti che tutto l'utilizzo di Android Studio e Android Native Development Kit sarà regolato dal Contratto di licenza del kit di sviluppo software Android disponibile su https://developer.android.com/studio/terms (tale URL può essere aggiornato o modificato da Google di volta in volta).

È necessario accettare i termini di servizio per scaricare il file. Conferma

  • Facoltativamente, puoi modificare la versione Android SDK o NDK. Metti il ​​file Docker scaricato in una cartella vuota e crea la tua immagine Docker eseguendo:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Avvia il contenitore Docker in modo interattivo montando la cartella corrente su / tmp all'interno del contenitore (nota che / tensorflow_src è il repository TensorFlow all'interno del contenitore):
docker run -it -v $PWD:/tmp tflite-builder bash

Se utilizzi PowerShell su Windows, sostituisci "$ PWD" con "pwd".

Se desideri utilizzare un repository TensorFlow sull'host, monta invece quella directory host (-v hostDir: / tmp).

  • Una volta che sei all'interno del contenitore, puoi eseguire quanto segue per scaricare ulteriori strumenti e librerie Android (tieni presente che potresti dover accettare la licenza):
android update sdk --no-ui -a --filter tools,platform-tools,android-${ANDROID_API_LEVEL},build-tools-${ANDROID_BUILD_TOOLS_VERSION}

È ora possibile procedere alla sezione "Compila e installa". Dopo aver finito di creare le librerie, è possibile copiarle in / tmp all'interno del contenitore in modo da potervi accedere sull'host.

Configura l'ambiente di compilazione senza Docker

Installa Bazel e prerequisiti Android

Bazel è il sistema di compilazione principale per TensorFlow. Per costruire con esso, devi averlo e Android NDK e SDK installati sul tuo sistema.

  1. Installa l'ultima versione del sistema di compilazione Bazel .
  2. Android NDK è necessario per creare il codice TensorFlow Lite nativo (C / C ++). L'attuale versione consigliata è la 17c, che può essere trovata qui .
  3. L'SDK Android e gli strumenti di compilazione possono essere ottenuti qui o, in alternativa, come parte di Android Studio . Build tools API> = 23 è la versione consigliata per la creazione di TensorFlow Lite.
Configurare WORKSPACE e .bazelrc

Esegui lo script ./configure nella directory principale di checkout di TensorFlow e rispondi "Sì" quando lo script chiede di configurare in modo interattivo ./WORKSPACE per build Android. Lo script tenterà di configurare le impostazioni utilizzando le seguenti variabili di ambiente:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Se queste variabili non sono impostate, devono essere fornite in modo interattivo nel prompt dello script. Una configurazione .tf_configure.bazelrc dovrebbe produrre voci simili alle seguenti nel file .tf_configure.bazelrc nella cartella principale:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r17c"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="28.0.3"
build --action_env ANDROID_SDK_API_LEVEL="23"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Crea e installa

Dopo aver configurato correttamente Bazel, puoi creare TensorFlow Lite AAR dalla directory di checkout principale come segue:

bazel build -c opt --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  //tensorflow/lite/java:tensorflow-lite

Questo genererà un file AAR in bazel-bin/tensorflow/lite/java/ . Si noti che questo crea un AAR "grasso" con diverse architetture; se non sono necessari tutti, utilizzare il sottoinsieme appropriato per l'ambiente di distribuzione.

bash tensorflow/lite/tools/build_aar.sh \
  --input_models=model1,model2 \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Lo script sopra genererà il file tensorflow-lite.aar e facoltativamente il file tensorflow-lite-select-tf-ops.aar se uno dei modelli utilizza Tensorflow ops.

Aggiungi AAR direttamente al progetto

Sposta il file tensorflow-lite.aar in una directory chiamata libs nel tuo progetto. Modifica il file build.gradle della tua app per fare riferimento alla nuova directory e sostituire la dipendenza TensorFlow Lite esistente con la nuova libreria locale, ad esempio:

allprojects {
    repositories {
        jcenter()
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}
Installa AAR nel repository Maven locale

Esegui il seguente comando dalla directory di checkout di root:

mvn install:install-file \
  -Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar

Nel build.gradle della tua app, assicurati di avere la dipendenza mavenLocal() e sostituisci la dipendenza TensorFlow Lite standard con quella che ha il supporto per operazioni TensorFlow selezionate:

allprojects {
    repositories {
        jcenter()
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Nota che la versione 0.1.100 qui è puramente per motivi di test / sviluppo. Con l'AAR locale installato, puoi utilizzare le API di inferenza Java standard di TensorFlow Lite nel codice dell'app.

Crea app Android utilizzando C ++

Esistono due modi per utilizzare TFLite tramite C ++ se costruisci la tua app con NDK:

Usa TFLite C API

Questo è l'approccio consigliato . Scarica l' AAR TensorFlow Lite ospitato in JCenter , rinominalo in tensorflow-lite-*.zip e decomprimilo. È necessario includere i quattro file di headers/tensorflow/lite/ nella headers/tensorflow/lite/ e headers/tensorflow/lite/c/ e la libreria dinamica libtensorflowlite_jni.so pertinente nella cartella jni/ nel progetto NDK.

Il file di intestazione c_api.h contiene la documentazione di base sull'utilizzo dell'API TFLite C.

Usa TFLite C ++ API

Se desideri utilizzare TFLite tramite l'API C ++, puoi creare le librerie condivise C ++:

Armeabi-v7a a 32 bit:

bazel build -c opt --config=android_arm //tensorflow/lite:libtensorflowlite.so

64 bit arm64-v8a:

bazel build -c opt --config=android_arm64 //tensorflow/lite:libtensorflowlite.so

Al momento non esiste un modo semplice per estrarre tutti i file di intestazione necessari, quindi è necessario includere tutti i file di intestazione in tensorflow/lite/ dal repository TensorFlow. Inoltre, avrete bisogno di intestazione file da FlatBuffers e Abseil .