Crea LiteRT per Android

In questo documento viene descritto come creare la libreria LiteRT per Android sul tuo personali. Normalmente, non è necessario creare localmente la libreria LiteRT per Android.

Usa istantanee notturne

Per usare le istantanee notturne, aggiungi il seguente repository alla 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 modificali in base alle esigenze) al file build.gradle

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Crea LiteRT in locale

In alcuni casi, potresti voler utilizzare una build locale di LiteRT. Per potresti creare un file binario personalizzato che include operative selezionate da TensorFlow, o apportare modifiche locali a LiteRT.

configura l'ambiente di build utilizzando Docker

  • Scarica il file Docker. Se scarichi il file Docker, accetti che il i seguenti termini di servizio regolano il tuo utilizzo:

Se fai clic sul pulsante di accettazione, accetti che tutti gli utilizzi di Android Studio e Android Native Development Kit sarà regolato dal Software Android Il Contratto di licenza del kit di sviluppo è disponibile all'indirizzo https://developer.android.com/studio/terms (questo URL potrebbe essere aggiornato o modificato da Google di tanto in tanto).

Devi accettare i Termini di servizio per scaricare l'app .

  • Facoltativamente, puoi modificare la versione dell'SDK Android o NDK. Inserisci l'oggetto scaricato Docker in una cartella vuota e crea la tua immagine Docker eseguendo:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Avvia il container Docker in modo interattivo montando la cartella corrente su /host_dir all'interno del container (tieni presente che /tensorflow_src è TensorFlow repository 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, montalo (-v hostDir:/host_dir).

  • Una volta all'interno del container, puoi eseguire il comando seguente per librerie e strumenti Android aggiuntivi (tieni presente che potresti dover accettare i 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 build.

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

Prerequisiti per installare Bazel e Android

Bazel è il sistema di compilazione principale per TensorFlow. Per utilizzarlo, devi avere installato sul sistema Android NDK e l'SDK.

  1. Installa la versione più recente del sistema di build Bazel.
  2. L'NDK di Android è necessario per sviluppare il modello LiteRT nativo (C/C++) le API nel tuo codice. L'attuale versione consigliata è la 25b, che puoi trovare qui
  3. È possibile ottenere l'SDK e gli strumenti di creazione qui oppure in alternativa nell'ambito di Android Studio. Costruire Tools API >= 23 è la versione consigliata per la creazione di LiteRT.

Configura WORKSPACE e .bazelrc

Si tratta di un passaggio di configurazione una tantum necessario per creare il file LiteRT librerie. Esegui lo script ./configure nel pagamento principale di TensorFlow e rispondi "Sì" quando lo script chiede di configurare in modo interattivo ./WORKSPACE per le build Android. Lo script tenterà di configurare le impostazioni utilizzando il metodo 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 nello 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

Dopo aver configurato correttamente Bazel, puoi creare l'AR LiteRT da nella directory di pagamento principale:

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/. Nota che questo dà un "grasso" AAR con diverse architetture; se non ne servono tutte, usa il sottoinsieme appropriato per il tuo ambiente di deployment.

Puoi creare file AAR più piccoli destinati solo a un insieme di modelli, come indicato di seguito:

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 valore tensorflow-lite-select-tf-ops.aar se uno dei modelli usa Operazioni TensorFlow. Per ulteriori dettagli, consulta Sezione Riduci le dimensioni binarie LiteRT.

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 sostituisco la dipendenza LiteRT esistente con la nuova libreria locale, e.g.:

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

Nell'build.gradle dell'app, assicurati di avere la dipendenza mavenLocal() e sostituire la dipendenza LiteRT standard con quella che supporta 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'
}

Tieni presente che la versione 0.1.100 qui è solo per amore di test/sviluppo. Con il componente AAR locale installato, puoi utilizzare lo standard API di inferenza Java LiteRT nel codice dell'app.