Crea TensorFlow Lite per Android

Questo documento descrive come creare autonomamente la libreria Android TensorFlow Lite. Normalmente, non è necessario creare localmente la libreria Android TensorFlow Lite. Se vuoi semplicemente usarlo, consulta la guida rapida di Android per maggiori dettagli su come usarli nei tuoi progetti Android.

Usa istantanee notturne

Per utilizzare le istantanee notturne, aggiungi il seguente repository alla configurazione della build Gradle root.

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

aggiungi istantanee notturne alle dipendenze (o modifica secondo necessità) al tuo build.gradle

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

Crea TensorFlow Lite localmente

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 regolano l'utilizzo:

Facendo clic per accettare, l'utente accetta che qualsiasi utilizzo di Android Studio e Android Native Development Kit sarà regolato dal contratto di licenza del kit di sviluppo software Android disponibile all'indirizzo https://developer.android.com/studio/terms (tale URL potrebbe essere aggiornato o modificato da Google di tanto in tanto).

Per scaricare il file devi accettare i termini di servizio.

  • Facoltativamente, puoi modificare la versione dell'SDK o dell'NDK di Android. Inserisci 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 /host_dir all'interno del contenitore (nota che /tensorflow_src è il repository TensorFlow all'interno del contenitore):
docker run -it -v $PWD:/host_dir tflite-builder bash

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

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

  • Una volta all'interno del contenitore, puoi eseguire quanto segue per scaricare ulteriori strumenti e librerie Android (tieni presente che potrebbe essere necessario accettare la licenza):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Ora dovresti procedere alla sezione Configura WORKSPACE e .bazelrc per configurare le impostazioni di compilazione.

Dopo aver finito di creare le librerie, puoi copiarle in /host_dir all'interno del contenitore in modo da potervi accedere sull'host.

Configura l'ambiente di compilazione senza Docker

Installa Bazel e i prerequisiti Android

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

  1. Installa l'ultima versione del sistema di compilazione Bazel .
  2. Per creare il codice TensorFlow Lite nativo (C/C++) è necessario Android NDK. La versione attualmente consigliata è la 25b, reperibile qui .
  3. L'SDK di Android e gli strumenti di creazione possono essere ottenuti qui o, in alternativa, come parte di Android Studio . L'API degli strumenti di creazione >= 23 è la versione consigliata per la creazione di TensorFlow Lite.

Configura WORKSPACE e .bazelrc

Si tratta di un passaggio di configurazione una tantum necessario per creare le librerie TF Lite. Esegui lo script ./configure nella directory root di pagamento di TensorFlow e rispondi "Sì" quando lo script richiede di configurare in modo interattivo le build ./WORKSPACE per 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 riuscita 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-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Costruisci e installa

Una volta configurato correttamente Bazel, puoi creare TensorFlow Lite AAR dalla directory di checkout root come segue:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //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 diverse; se non ti servono tutti, utilizza il sottoinsieme appropriato per il tuo ambiente di distribuzione.

Puoi creare file AAR più piccoli destinati solo a una serie di modelli come segue:

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, consulta la sezione Riduci le dimensioni del binario 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 {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

Installa AAR nel repository Maven locale

Esegui il seguente comando dalla directory di checkout 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 di TensorFlow Lite con quella che supporta le operazioni TensorFlow selezionate:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

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

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