Creazione di TensorFlow Lite per Android

Questo documento descrive come creare autonomamente la libreria Android TensorFlow Lite. Di solito, non è necessario creare in locale la libreria Android TensorFlow Lite per Android.

Usare le istantanee notturne

Per utilizzare gli snapshot notturni, aggiungi il seguente repository alla configurazione della build Gradle principale.

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 snapshot notturni alle dipendenze (o apporta modifiche in base alle esigenze) a 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 in locale

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

configura l'ambiente di compilazione utilizzando Docker

  • Scarica il file Docker. Scaricando il file Docker, l'utente accetta che il suo utilizzo sia regolato dai seguenti termini di servizio:

Se fai clic per accettare, accetti che l'utilizzo di Android Studio e del Native Development Kit Android sia regolato dal Contratto di licenza del kit di sviluppo software Android disponibile all'indirizzo https://developer.android.com/studio/terms (questo URL può essere aggiornato o modificato di volta in volta da Google).

Devi accettare i Termini di servizio per scaricare il file.

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

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

Se vuoi utilizzare un repository TensorFlow sull'host, montala invece (-v hostDir:/host_dir).

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

Ora devi passare alla sezione Configura WORKSPACE e .bazelrc per configurare le impostazioni di compilazione.

Dopo aver completato la creazione delle librerie, puoi copiarle in /host_dir all'interno del container in modo da potervi accedere sull'host.

Configura l'ambiente di build senza Docker

Installa i prerequisiti di Bazel e Android

Bazel è il sistema di build principale di TensorFlow. Per utilizzare questo strumento, devi avere installato sul sistema l'SDK NDK e l'SDK di Android.

  1. Installa la versione più recente del sistema di build Bazel.
  2. L'NDK di Android è necessario per creare il codice nativo (C/C++) di TensorFlow Lite. L'attuale versione consigliata è la 25b, che puoi trovare qui.
  3. L'SDK Android e gli strumenti di creazione sono disponibili qui o in alternativa come parte di Android Studio. L'API Build tools >= 23 è la versione consigliata per creare TensorFlow Lite.

Configura WORKSPACE e .bazelrc

Questo passaggio di configurazione da eseguire una sola volta è necessario per creare le librerie TF Lite. Esegui lo script ./configure nella directory di pagamento principale di TensorFlow e rispondi "Sì" quando lo script richiede di configurare in modo interattivo ./WORKSPACE per le 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 nella richiesta di script. La configurazione corretta dovrebbe restituire 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"

Crea e installa

Una volta configurato correttamente Bazel, puoi creare l'AAR TensorFlow Lite dalla directory di pagamento radice nel seguente modo:

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

Verrà generato un file AAR in bazel-bin/tensorflow/lite/java/. Tieni presente che questo crea un AAR "grasso" con diverse architetture; se non ti servono tutte, utilizza il sottoinsieme appropriato per l'ambiente di deployment.

Puoi creare file AAR più piccoli che hanno come target solo un insieme di modelli nel seguente modo:

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

Lo script riportato sopra genererà il file tensorflow-lite.aar e, facoltativamente, il file tensorflow-lite-select-tf-ops.aar se uno dei modelli utilizza le operazioni Tensorflow. Per maggiori dettagli, consulta la sezione Ridurre le dimensioni del programma binario di TensorFlow Lite.

Aggiungi AAR direttamente al progetto

Sposta il file tensorflow-lite.aar in una directory denominata libs nel tuo progetto. Modifica il file build.gradle dell'app in modo che faccia riferimento alla nuova directory e sostituisci 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 questo comando dalla directory di pagamento principale:

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 dell'app, assicurati di avere la dipendenza mavenLocal() e sostituisci la dipendenza standard di TensorFlow Lite con quella che supporta determinate operazioni TensorFlow:

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 è solo a scopo di test/sviluppo. Con l'AAR locale installato, puoi utilizzare le API di inferenza Java di TensorFlow Lite standard nel codice dell'app.