Ti presentiamo Google AI Edge Portal: esegui il benchmarking dell'IA di Edge su larga scala. Registrati per richiedere l'accesso durante l'anteprima privata.

Questa pagina è stata tradotta dall'API Cloud Translation.

Crea LiteRT per Android

Questo documento descrive come creare autonomamente la libreria Android LiteRT. Normalmente, non è necessario creare localmente la libreria Android LiteRT.

Utilizzare gli snapshot notturni

Per utilizzare gli snapshot notturni, aggiungi il seguente repository alla configurazione di build Gradle radice.

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 gli 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'
    ...
}
...

Creare LiteRT localmente

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

Configura l'ambiente di build utilizzando Docker

Scarica il file Docker. Se scarichi il file Docker, accetti che il tuo utilizzo sia regolato dai seguenti Termini di servizio:

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

Per scaricare il file, devi accettare i Termini di servizio.

Se vuoi, puoi modificare la versione dell'SDK Android o dell'NDK. Inserisci il file Docker scaricato in una cartella vuota e crea l'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 è 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, monta invece la directory host (-v hostDir:/host_dir).

Una volta all'interno del container, puoi eseguire il seguente comando per scaricare librerie e strumenti 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 devi passare alla sezione Configurare WORKSPACE e .bazelrc per configurare le impostazioni di build.

Dopo aver creato le librerie, puoi copiarle in /host_dir all'interno del container in modo da potervi accedere sull'host.

Configurare l'ambiente di build senza Docker

Installare Bazel e i prerequisiti di Android

Bazel è il sistema di compilazione principale per TensorFlow. Per creare con questo strumento, devi averlo installato insieme all'NDK e all'SDK Android sul tuo sistema.

Installa l'ultima versione del sistema di build Bazel.
L'NDK Android è necessario per creare il codice LiteRT nativo (C/C++). La versione consigliata attuale è la 25b, disponibile qui.
1. L'SDK Android e gli strumenti di compilazione possono essere ottenuti qui, o in alternativa come parte di Android Studio. Strumenti di compilazione L'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 le librerie LiteRT. Esegui lo script ./configure nella directory di controllo di TensorFlow principale e rispondi "Yes" (Sì) quando lo script chiede 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 nel prompt dello script. La configurazione riuscita dovrebbe generare 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"

Creazione e installazione

Una volta configurato correttamente Bazel, puoi creare l'AAR LiteRT dalla directory di estrazione principale come segue:

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 viene creato un AAR "fat" 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 precedente genererà il file tensorflow-lite.aar e, facoltativamente, il file tensorflow-lite-select-tf-ops.aar se uno dei modelli utilizza operazioni TensorFlow. Per maggiori dettagli, consulta la sezione Ridurre le dimensioni del binario LiteRT.

Aggiungere l'AAR direttamente al progetto

Sposta il file tensorflow-lite.aar in una directory denominata libs nel tuo progetto. Modifica il file build.gradle della tua app in modo che faccia riferimento alla nuova directory e sostituisci la dipendenza LiteRT 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 estrazione 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 LiteRT standard con quella che supporta 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 è puramente a scopo di test/sviluppo. Con l'AAR locale installato, puoi utilizzare le API di inferenza Java LiteRT standard nel codice dell'app.