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

Crea TensorFlow Lite per Android

Questo documento descrive come creare autonomamente la libreria Android di TensorFlow Lite. Normalmente, non è necessario creare localmente la libreria Android TensorFlow Lite. Se vuoi solo usarlo, il modo più semplice è usare TensorFlow Lite AAR ospitato in JCenter . Consulta la guida rapida di Android per maggiori dettagli su come utilizzarli nei tuoi progetti Android.

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. Riconoscere

  • 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 all'interno del contenitore, è possibile eseguire quanto segue per scaricare ulteriori strumenti e librerie Android (si noti che potrebbe essere necessario 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

Una volta 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 ti servono tutti, utilizza il sottoinsieme appropriato per il tuo 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. Per maggiori dettagli, vedere la sezione Ridurre le dimensioni binarie di TensorFlow Lite .

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 standard TensorFlow Lite 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.