Questa pagina è stata tradotta dall'API Cloud Translation.

Crea TensorFlow Lite per Android

Questo documento descrive come creare da solo la libreria Android TensorFlow Lite. Normalmente, non è necessario creare localmente la libreria Android TensorFlow Lite. Se vuoi solo usarlo, consulta la guida rapida 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'
        }
    }
}

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.

Configurare 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 tutto l'utilizzo 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 tanto in tanto).

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

Facoltativamente, puoi modificare 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 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 Configure WORKSPACE e .bazelrc per configurare le impostazioni di build.

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

Configurare l'ambiente di compilazione senza Docker

Installa i prerequisiti di Bazel e Android

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

Installa l'ultima versione del sistema di compilazione Bazel .
L'Android NDK è necessario per creare il codice TensorFlow Lite nativo (C/C++). L'attuale versione consigliata è la 21e, che può essere trovata qui .
L'SDK di Android e gli strumenti di compilazione 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 checkout di TensorFlow e rispondi "Sì" quando lo script chiede 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-r21e"
build --action_env ANDROID_NDK_API_LEVEL="26"
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 che Bazel è configurato correttamente, puoi creare TensorFlow Lite AAR dalla directory root checkout come segue:

bazel build -c opt --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
  --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; 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 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, consulta la sezione Ridurre la dimensione binaria 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 tua directory root checkout:

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 ha il supporto per 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'
}

Si noti 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 della tua app.