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.
- Installa la versione più recente del sistema di build Bazel.
- 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.
- 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.