Crea TensorFlow Lite per Android

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo documento descrive come creare autonomamente la libreria TensorFlow Lite per Android. Normalmente, non è necessario creare localmente la libreria Android TensorFlow Lite. Se desideri semplicemente utilizzarlo, consulta la guida introduttiva di Android per maggiori dettagli su come utilizzarli nei tuoi progetti Android.

Usa le istantanee notturne

Per utilizzare le istantanee notturne, aggiungi il seguente repository alla configurazione di build di Gradle di 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'
        }
    }
}

Crea TensorFlow Lite in locale

In alcuni casi, potresti voler utilizzare una build locale di TensorFlow Lite. Ad esempio, potresti creare un binario personalizzato che includa operazioni selezionate da TensorFlow o 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, con la presente accetti che tutto l'uso di Android Studio e Android Native Development Kit sarà regolato dall'Accordo di licenza per Android Software Development Kit disponibile all'indirizzo https://developer.android.com/studio/terms (tale URL potrebbe essere aggiornato o modificato da Google di volta in volta).

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

  • È possibile modificare facoltativamente la versione di 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 in /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 utilizzi PowerShell su Windows, sostituisci "$PWD" con "pwd".

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

  • Una volta che sei all'interno del contenitore, puoi eseguire quanto segue per scaricare strumenti e librerie Android aggiuntivi (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 build.

Dopo aver terminato la creazione delle 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 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 build Bazel .
  2. Android NDK è necessario per creare il codice TensorFlow Lite nativo (C/C++). L'attuale versione consigliata è 19c, che può essere trovata qui .
  3. L'SDK di 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.

Configura WORKSPACE e .bazelrc

Questo è un passaggio di configurazione una tantum necessario per creare le librerie TF Lite. Esegui lo script ./configure nella directory di verifica principale di TensorFlow e rispondi "Sì" quando lo script chiede di configurare in modo interattivo le ./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. La corretta configurazione 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-r19c"
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"

Costruisci e installa

Dopo aver configurato correttamente Bazel, è possibile 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, usa il sottoinsieme appropriato per il tuo ambiente di distribuzione.

Puoi creare file AAR più piccoli destinati solo a un insieme 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 precedente 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 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 il seguente comando dalla directory di checkout 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 della tua app, assicurati di avere la dipendenza mavenLocal() e sostituisci la dipendenza TensorFlow Lite standard 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'
}

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.